602 lines
21 KiB
Python
602 lines
21 KiB
Python
import dataclasses
|
|
import itertools
|
|
import sys
|
|
|
|
from tclint.parser import Parser
|
|
from tclint.syntax_tree import (
|
|
ArgExpansion,
|
|
BareWord,
|
|
BinaryOp,
|
|
BracedExpression,
|
|
BracedWord,
|
|
Command,
|
|
CommandSub,
|
|
Comment,
|
|
CompoundBareWord,
|
|
Expression,
|
|
Function,
|
|
List,
|
|
Node,
|
|
ParenExpression,
|
|
QuotedWord,
|
|
Script,
|
|
TernaryOp,
|
|
UnaryOp,
|
|
VarSub,
|
|
)
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class LiteralBlock:
|
|
block: list[str]
|
|
pos: tuple[int, int]
|
|
end_pos: tuple[int, int]
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class FormatterOpts:
|
|
indent: str
|
|
spaces_in_braces: bool
|
|
balanced_spaces_in_braces: bool
|
|
max_blank_lines: int
|
|
indent_namespace_eval: bool
|
|
indent_mixed_tab_size: int
|
|
emacs: bool
|
|
debug_whitespace: bool
|
|
|
|
|
|
class Formatter:
|
|
def __init__(self, opts: FormatterOpts):
|
|
self.opts = opts
|
|
self.indent_mixed_tab_size = opts.indent_mixed_tab_size
|
|
|
|
def _indent(self, lines: list[str], indent: str) -> list[str]:
|
|
indented = []
|
|
for line in lines:
|
|
if line == "":
|
|
indented.append("")
|
|
else:
|
|
indented.append(indent + line)
|
|
|
|
return indented
|
|
|
|
def space(self, debug_char, space=None):
|
|
"""Returns a string required for indentation or separation.
|
|
|
|
By default, just returns a string of space. If enabled using
|
|
`--debug-whitespace`, returns a string of debug_char.
|
|
"""
|
|
assert len(debug_char) == 1
|
|
if space is None:
|
|
space = self.opts.indent
|
|
if self.opts.debug_whitespace:
|
|
# Enable this to return a string of debug_char.
|
|
return len(space) * debug_char
|
|
return space
|
|
|
|
def get_spaces_in_braces(self, space: tuple[int, int]):
|
|
spaces_in_braces = self.space("A", " ") if self.opts.spaces_in_braces else ""
|
|
if not self.opts.balanced_spaces_in_braces:
|
|
# No balancing.
|
|
return spaces_in_braces
|
|
|
|
if space[0] == -1 and space[1] == -1:
|
|
# No info to do balancing.
|
|
return spaces_in_braces
|
|
|
|
assert not (space[0] == -1 and space[1] != -1)
|
|
if space[0] != -1 and space[1] == -1:
|
|
# we've got empty braces. Keep "{}" and "{ }" as is, but normalize
|
|
# more than one space to a single space.
|
|
return min(space[0], 1) * self.space("B", " ")
|
|
|
|
# Normalize more than one space to a single space.
|
|
before = min(space[0], 1)
|
|
after = min(space[1], 1)
|
|
if before + after == 1:
|
|
# If we have an unbalanced expression like "{1 }" or "{ 1}",
|
|
# transform it to either "{1}" or "{ 1 }", using spaces_in_braces.
|
|
return spaces_in_braces
|
|
|
|
# Check that we have a balanced expression.
|
|
assert before == after
|
|
# Keep either "{1}" or "{ 1 }".
|
|
return before * self.space("C", " ")
|
|
|
|
def _brace(self, lines: list[str], space: tuple[int, int]) -> list[str]:
|
|
"""Format content between braces.
|
|
|
|
The space argument indicates the amount of space in the input, for
|
|
instance:
|
|
- (1, 0) to represent 1 space before and no space after, for "{ 1}", and
|
|
- (0, -1) to represent no space, for "{}".
|
|
"""
|
|
|
|
spaces_in_braces = self.get_spaces_in_braces(space)
|
|
if lines == [""]:
|
|
# Empty braces.
|
|
return ["{" + spaces_in_braces + "}"]
|
|
|
|
# Not empty braces.
|
|
braced_lines = lines[:]
|
|
braced_lines[0] = "{" + spaces_in_braces + lines[0]
|
|
braced_lines[-1] += spaces_in_braces + "}"
|
|
return braced_lines
|
|
|
|
def format(self, *nodes: Node | LiteralBlock) -> list[str]:
|
|
formatted = []
|
|
for node in nodes:
|
|
if isinstance(node, Script):
|
|
formatted += self.format_script(node)
|
|
elif isinstance(node, Command):
|
|
formatted += self.format_command(node)
|
|
elif isinstance(node, Comment):
|
|
formatted += self.format_comment(node)
|
|
elif isinstance(node, CommandSub):
|
|
formatted += self.format_command_sub(node)
|
|
elif isinstance(node, BareWord):
|
|
formatted += self.format_bare_word(node)
|
|
elif isinstance(node, QuotedWord):
|
|
formatted += self.format_quoted_word(node)
|
|
elif isinstance(node, BracedWord):
|
|
formatted += self.format_braced_word(node)
|
|
elif isinstance(node, CompoundBareWord):
|
|
formatted += self.format_compound_bare_word(node)
|
|
elif isinstance(node, VarSub):
|
|
formatted += self.format_var_sub(node)
|
|
elif isinstance(node, ArgExpansion):
|
|
formatted += self.format_arg_expansion(node)
|
|
elif isinstance(node, List):
|
|
formatted += self.format_list(node)
|
|
elif isinstance(node, Expression):
|
|
formatted += self.format_expression(node)
|
|
elif isinstance(node, BracedExpression):
|
|
formatted += self.format_braced_expression(node)
|
|
elif isinstance(node, ParenExpression):
|
|
formatted += self.format_paren_expression(node)
|
|
elif isinstance(node, UnaryOp):
|
|
formatted += self.format_unary_op(node)
|
|
elif isinstance(node, BinaryOp):
|
|
formatted += self.format_binary_op(node)
|
|
elif isinstance(node, TernaryOp):
|
|
formatted += self.format_ternary_op(node)
|
|
elif isinstance(node, Function):
|
|
formatted += self.format_function(node)
|
|
elif isinstance(node, LiteralBlock):
|
|
formatted += node.block
|
|
else:
|
|
assert False, f"unrecognized node: {type(node)}"
|
|
|
|
return formatted
|
|
|
|
def reindent(self, lines: list[str]) -> list[str]:
|
|
"""Apply mixed space/tab indentation scheme.
|
|
|
|
Apply the mixed space/tab indentation scheme as requested by
|
|
--indent=mixed,<s>,<t>.
|
|
|
|
The input is lines with indentation in the form of spaces and/or tabs.
|
|
This function transforms the indentation into a number of tabs,
|
|
followed by a number of spaces.
|
|
|
|
A more structural way of doing this would be to model input lines as a
|
|
tuple of an indentation level and a string, and use this function to
|
|
expand the indentation level, but that requires broader changes.
|
|
"""
|
|
tab_size = self.indent_mixed_tab_size
|
|
if tab_size == 0:
|
|
return lines
|
|
|
|
fixed_lines = []
|
|
for line in lines:
|
|
# Split line into leading whitespace, and the rest.
|
|
after = line.lstrip()
|
|
split_pos = len(line) - len(after)
|
|
leading = line[0:split_pos]
|
|
|
|
# Expand tabs.
|
|
leading = leading.expandtabs(tab_size)
|
|
|
|
# Tabify.
|
|
leading = leading.replace(" " * tab_size, "\t")
|
|
|
|
fixed_lines.append(leading + after)
|
|
|
|
return fixed_lines
|
|
|
|
def format_top(self, script: str, parser: Parser) -> str:
|
|
tree = parser.parse(script)
|
|
self.script = script.split("\n")
|
|
lines = self.format_script_contents(tree)
|
|
lines = self.reindent(lines)
|
|
return "\n".join(lines) + "\n"
|
|
|
|
def format_partial(self, script: str, parser: Parser) -> str:
|
|
"""Formats a partial Tcl script.
|
|
|
|
This function formats a partial script according to the gofmt partial formatting
|
|
rules, "[preserving] leading indentation as well as leading and trailing spaces"
|
|
(ref: https://pkg.go.dev/cmd/gofmt#pkg-overview). Unlike Go, we have no way of
|
|
detecting if a given script is a program fragment, hence the distinct method
|
|
from `format_top` .
|
|
"""
|
|
leading = "".join(itertools.takewhile(str.isspace, script))
|
|
try:
|
|
leading, indent = leading.rsplit("\n", 1)
|
|
leading += "\n"
|
|
except ValueError:
|
|
leading, indent = "", leading
|
|
trailing = "".join(itertools.takewhile(str.isspace, reversed(script)))[::-1]
|
|
|
|
script = script.strip()
|
|
tree = parser.parse(script)
|
|
self.script = script.split("\n")
|
|
|
|
lines = self._indent(self.format_script_contents(tree), indent)
|
|
lines = self.reindent(lines)
|
|
formatted = "\n".join(lines)
|
|
|
|
return leading + formatted + trailing
|
|
|
|
def format_script_contents(self, script: Script | CommandSub) -> list[str]:
|
|
to_format = []
|
|
skip_formatting_start = None
|
|
for child in script.children:
|
|
if skip_formatting_start is None:
|
|
to_format.append(child)
|
|
|
|
if isinstance(child, Comment):
|
|
if child.value.strip() == "tclfmt-disable":
|
|
if skip_formatting_start is not None:
|
|
print(
|
|
"Warning: encountered 'tclint-disable' while formatting is"
|
|
" already disabled, ignoring...",
|
|
file=sys.stderr,
|
|
)
|
|
else:
|
|
skip_formatting_start = child.pos[0]
|
|
elif child.value.strip() == "tclfmt-enable":
|
|
if skip_formatting_start is None:
|
|
print(
|
|
"Warning: encountered 'tclint-enable' while formatting is"
|
|
" already disabled, ignoring...",
|
|
file=sys.stderr,
|
|
)
|
|
else:
|
|
skip_formatting_end = child.pos[0]
|
|
block = self.script[skip_formatting_start:skip_formatting_end]
|
|
to_format.append(
|
|
LiteralBlock(
|
|
block,
|
|
pos=(skip_formatting_start + 1, 1),
|
|
end_pos=(skip_formatting_end, 1),
|
|
)
|
|
)
|
|
skip_formatting_start = None
|
|
|
|
if skip_formatting_start is not None:
|
|
print("Warning: missing 'tclint-enable'", file=sys.stderr)
|
|
to_format.append(
|
|
LiteralBlock(
|
|
self.script[skip_formatting_start:],
|
|
pos=(skip_formatting_start + 1, 1),
|
|
end_pos=script.end_pos,
|
|
)
|
|
)
|
|
|
|
formatted = [""]
|
|
last_line = None
|
|
for child in to_format:
|
|
if last_line is not None:
|
|
if last_line == child.pos[0]:
|
|
if isinstance(child, Comment):
|
|
formatted[-1] += " ;"
|
|
else:
|
|
formatted[-1] += "; "
|
|
else:
|
|
newlines = child.pos[0] - last_line
|
|
newlines = min(newlines, self.opts.max_blank_lines + 1)
|
|
formatted.extend([""] * newlines)
|
|
last_line = child.end_pos[0]
|
|
|
|
lines = self.format(child)
|
|
formatted[-1] += lines[0]
|
|
formatted.extend(lines[1:])
|
|
|
|
return formatted
|
|
|
|
def format_script(self, script: Script, should_indent=True) -> list[str]:
|
|
lines = self.format_script_contents(script)
|
|
if script.pos[0] == script.end_pos[0]:
|
|
space_before = -1
|
|
space_after = -1
|
|
if len(script.children) != 0:
|
|
space_before = script.children[0].pos[1] - script.pos[1] - 1
|
|
space_after = script.end_pos[1] - script.children[-1].end_pos[1] - 1
|
|
else:
|
|
space_before = script.end_pos[1] - script.pos[1] - 2
|
|
return self._brace(lines, (space_before, space_after))
|
|
|
|
# Usually, we enforce that multi-line scripts start on a new line after the open
|
|
# brace. However, if a comment was originally on the same line as the open brace
|
|
# we preserve it, since it's probably meant to be associated with this line
|
|
# (e.g. a tclint-disable-line).
|
|
open_brace = "{"
|
|
if (
|
|
len(script.children) > 0
|
|
and isinstance(script.children[0], Comment)
|
|
and script.pos[0] == script.children[0].pos[0]
|
|
):
|
|
open_brace += self.space("D", " ") + lines[0]
|
|
lines = lines[1:]
|
|
|
|
if should_indent:
|
|
return [open_brace] + self._indent(lines, self.space("E")) + ["}"]
|
|
else:
|
|
return [open_brace] + lines + ["}"]
|
|
|
|
def format_command(self, command: Command) -> list[str]:
|
|
is_namespace_eval = (
|
|
command.routine.contents == "namespace"
|
|
and len(command.args) > 0
|
|
and command.args[0].contents == "eval"
|
|
)
|
|
should_indent = not is_namespace_eval or self.opts.indent_namespace_eval
|
|
|
|
hanging_indent = False
|
|
formatted = self.format(command.routine)
|
|
last_line = command.routine.end_pos[0]
|
|
for child in command.args:
|
|
if isinstance(child, Script):
|
|
child_lines = self.format_script(child, should_indent=should_indent)
|
|
else:
|
|
child_lines = self.format(child)
|
|
|
|
if last_line == child.pos[0]:
|
|
formatted[-1] += self.space("F", " ")
|
|
if self.opts.emacs and child_lines[0][-1] == "\\":
|
|
base_indent = (len(formatted[-1])) * self.space("G", " ")
|
|
else:
|
|
base_indent = ""
|
|
formatted[-1] += child_lines[0]
|
|
else:
|
|
formatted[-1] += self.space("H", " ") + "\\"
|
|
formatted.append(self.space("I") + child_lines[0])
|
|
hanging_indent = True
|
|
|
|
if hanging_indent:
|
|
formatted.extend(self._indent(child_lines[1:], self.space("J")))
|
|
else:
|
|
formatted.extend(self._indent(child_lines[1:], base_indent))
|
|
|
|
last_line = child.end_pos[0]
|
|
|
|
return formatted
|
|
|
|
def format_comment(self, comment: Comment) -> list[str]:
|
|
return [f"#{comment.value}"]
|
|
|
|
def format_command_sub(self, command_sub):
|
|
if len(command_sub.children) == 0:
|
|
return ["[]"]
|
|
|
|
formatted = []
|
|
contents = self.format_script_contents(command_sub)
|
|
if len(command_sub.children) > 1 and len(contents) > 1:
|
|
formatted.append("[")
|
|
formatted.extend(self._indent(contents, self.space("K")))
|
|
formatted.append("]")
|
|
else:
|
|
formatted.append("[" + contents[0])
|
|
if self.opts.emacs:
|
|
indent = self.space("L", " ")
|
|
else:
|
|
indent = ""
|
|
formatted.extend(self._indent(contents[1:], indent))
|
|
formatted[-1] += "]"
|
|
|
|
return formatted
|
|
|
|
def format_bare_word(self, word) -> list[str]:
|
|
# Property enforced by parser
|
|
assert word.contents is not None
|
|
return [word.contents]
|
|
|
|
def format_quoted_word(self, word) -> list[str]:
|
|
if word.contents is not None:
|
|
return [f'"{word.contents}"']
|
|
|
|
formatted = ""
|
|
for child in word.children:
|
|
formatted += "\n".join(self.format(child))
|
|
|
|
return [f'"{formatted}"']
|
|
|
|
def format_braced_word(self, word) -> list[str]:
|
|
assert word.contents is not None
|
|
return [f"{{{word.contents}}}"]
|
|
|
|
def format_compound_bare_word(self, word) -> list[str]:
|
|
formatted = [""]
|
|
for child in word.children:
|
|
child_lines = self.format(child)
|
|
formatted[-1] += child_lines[0]
|
|
formatted.extend(child_lines[1:])
|
|
|
|
return formatted
|
|
|
|
def format_var_sub(self, varsub) -> list[str]:
|
|
# We might be able to make the formatter infer whether braces are required, and
|
|
# remove them from the syntax tree. For now it's easier to just mimic the
|
|
# original format.
|
|
if varsub.braced:
|
|
formatted = [f"${{{varsub.value}}}"]
|
|
else:
|
|
formatted = [f"${varsub.value}"]
|
|
|
|
if varsub.children:
|
|
# We just concatenate everything as is, since changes in whitespace are
|
|
# semantically meaningful in this context. Any newlines are captured by
|
|
# BareWords.
|
|
formatted[-1] += "("
|
|
for child in varsub.children:
|
|
child_lines = self.format(child)
|
|
formatted[-1] += child_lines[0]
|
|
formatted.extend(child_lines[1:])
|
|
formatted[-1] += ")"
|
|
|
|
return formatted
|
|
|
|
def format_arg_expansion(self, arg_expansion) -> list[str]:
|
|
lines = self.format(arg_expansion.list)
|
|
lines[0] = "{*}" + lines[0]
|
|
|
|
return lines
|
|
|
|
def format_list(self, list_node) -> list[str]:
|
|
# Similar to Script, but the contents are a bit more straightforward.
|
|
contents = [""]
|
|
last_line = None
|
|
for child in list_node.children:
|
|
if last_line is not None:
|
|
if last_line == child.pos[0]:
|
|
contents[-1] += self.space("M", " ")
|
|
else:
|
|
newlines = child.pos[0] - last_line
|
|
newlines = min(newlines, 3)
|
|
contents.extend([""] * newlines)
|
|
|
|
lines = self.format(child)
|
|
contents[-1] += lines[0]
|
|
contents.extend(lines[1:])
|
|
|
|
last_line = child.end_pos[0]
|
|
|
|
if list_node.pos[0] == list_node.end_pos[0]:
|
|
space_before = -1
|
|
space_after = -1
|
|
if len(list_node.children) != 0:
|
|
space_before = list_node.children[0].pos[1] - list_node.pos[1] - 1
|
|
space_after = (
|
|
list_node.end_pos[1] - list_node.children[-1].end_pos[1] - 1
|
|
)
|
|
else:
|
|
space_before = list_node.end_pos[1] - list_node.pos[1] - 2
|
|
return self._brace(contents, (space_before, space_after))
|
|
|
|
return ["{"] + self._indent(contents, self.space("N")) + ["}"]
|
|
|
|
def format_expression(self, expr) -> list[str]:
|
|
formatted = [""]
|
|
for child in expr.children:
|
|
lines = self.format(child)
|
|
formatted[-1] += lines[0]
|
|
for line in lines[1:]:
|
|
formatted[-1] += " \\"
|
|
formatted += self._indent([line], self.space("O"))
|
|
|
|
# Trick: we know there are quotes around the expression if the start of the
|
|
# expression is a different column than its first child.
|
|
quoted = expr.pos[1] != expr.children[0].pos[1]
|
|
if quoted:
|
|
formatted[0] = '"' + formatted[0]
|
|
formatted[-1] += '"'
|
|
|
|
return formatted
|
|
|
|
def format_braced_expression(self, expr) -> list[str]:
|
|
formatted = [""]
|
|
for child in expr.children:
|
|
lines = self.format(child)
|
|
formatted[-1] += lines[0]
|
|
formatted.extend(lines[1:])
|
|
|
|
if expr.pos[0] == expr.end_pos[0]:
|
|
space_before = expr.children[0].pos[1] - expr.pos[1] - 1
|
|
space_after = expr.end_pos[1] - expr.children[-1].end_pos[1] - 1
|
|
return self._brace(formatted, (space_before, space_after))
|
|
|
|
return ["{"] + self._indent(formatted, self.space("P")) + ["}"]
|
|
|
|
def format_paren_expression(self, expr) -> list[str]:
|
|
body = expr.body
|
|
|
|
formatted = ["("]
|
|
lines = self.format(body)
|
|
if expr.pos[0] != body.pos[0]:
|
|
formatted.extend(lines)
|
|
else:
|
|
formatted[-1] += lines[0]
|
|
formatted.extend(lines[1:])
|
|
|
|
formatted = formatted[0:1] + self._indent(formatted[1:], self.space("Q"))
|
|
|
|
if expr.end_pos[0] != body.end_pos[0]:
|
|
formatted.append(")")
|
|
else:
|
|
formatted[-1] += ")"
|
|
|
|
return formatted
|
|
|
|
def format_unary_op(self, expr):
|
|
op = self.format(expr.operator)
|
|
assert len(op) == 1
|
|
|
|
lines = self.format(expr.operand)
|
|
lines[0] = op[0] + lines[0]
|
|
return lines
|
|
|
|
def _format_op(self, expr) -> list[str]:
|
|
nodes = expr.children
|
|
formatted = self.format(nodes[0])
|
|
|
|
last = nodes[0]
|
|
for next in nodes[1:]:
|
|
lines = self.format(next)
|
|
if last.end_pos[0] != next.pos[0]:
|
|
formatted.extend(lines)
|
|
else:
|
|
formatted[-1] += self.space("R", " ")
|
|
formatted[-1] += lines[0]
|
|
formatted.extend(lines[1:])
|
|
last = next
|
|
|
|
return formatted
|
|
|
|
def format_binary_op(self, expr) -> list[str]:
|
|
return self._format_op(expr)
|
|
|
|
def format_ternary_op(self, expr) -> list[str]:
|
|
return self._format_op(expr)
|
|
|
|
def format_function(self, function):
|
|
name_parts = self.format(function.name)
|
|
assert len(name_parts) == 1
|
|
name = name_parts[0]
|
|
|
|
formatted = [f"{name}("]
|
|
|
|
last = function.name
|
|
for i, child in enumerate(function.args):
|
|
if i > 0:
|
|
formatted[-1] += ","
|
|
lines = self.format(child)
|
|
if last.end_pos[0] != child.pos[0]:
|
|
formatted.extend(lines)
|
|
else:
|
|
if i > 0:
|
|
formatted[-1] += self.space("S", " ")
|
|
formatted[-1] += lines[0]
|
|
formatted.extend(lines[1:])
|
|
last = child
|
|
|
|
# indent any continuation lines, but we leave the closing paren dedented
|
|
formatted = formatted[0:1] + self._indent(formatted[1:], self.space("T"))
|
|
|
|
if last.end_pos[0] != function.end_pos[0]:
|
|
formatted.append(")")
|
|
else:
|
|
formatted[-1] += ")"
|
|
|
|
return formatted
|