dst_contents += str(line)
else:
comments.append(current_line)
- for comment in comments:
- dst_contents += str(comment)
+ if comments:
+ if elt.previous_defs:
+ # Separate postscriptum comments from the last module-level def.
+ dst_contents += str(empty_line)
+ dst_contents += str(empty_line)
+ for comment in comments:
+ dst_contents += str(comment)
return dst_contents
if leaf.type == token.STRING and self.previous.type == token.STRING:
self.delimiters[id(self.previous)] = STRING_PRIORITY
elif (
- leaf.type == token.NAME and
- leaf.value == 'for' and
- leaf.parent and
- leaf.parent.type in {syms.comp_for, syms.old_comp_for}
+ leaf.type == token.NAME
+ and leaf.value == 'for'
+ and leaf.parent
+ and leaf.parent.type in {syms.comp_for, syms.old_comp_for}
):
self.delimiters[id(self.previous)] = COMPREHENSION_PRIORITY
elif (
- leaf.type == token.NAME and
- leaf.value == 'if' and
- leaf.parent and
- leaf.parent.type in {syms.comp_if, syms.old_comp_if}
+ leaf.type == token.NAME
+ and leaf.value == 'if'
+ and leaf.parent
+ and leaf.parent.type in {syms.comp_if, syms.old_comp_if}
):
self.delimiters[id(self.previous)] = COMPREHENSION_PRIORITY
+ elif (
+ leaf.type == token.NAME
+ and leaf.value in LOGIC_OPERATORS
+ and leaf.parent
+ ):
+ self.delimiters[id(self.previous)] = LOGIC_PRIORITY
if leaf.type in OPENING_BRACKETS:
self.bracket_match[self.depth, BRACKET[leaf.type]] = leaf
self.depth += 1
@property
def is_class(self) -> bool:
return (
- bool(self) and
- self.leaves[0].type == token.NAME and
- self.leaves[0].value == 'class'
+ bool(self)
+ and self.leaves[0].type == token.NAME
+ and self.leaves[0].value == 'class'
)
@property
except IndexError:
second_leaf = None
return (
- (first_leaf.type == token.NAME and first_leaf.value == 'def') or
- (
- first_leaf.type == token.NAME and
- first_leaf.value == 'async' and
- second_leaf is not None and
- second_leaf.type == token.NAME and
- second_leaf.value == 'def'
+ (first_leaf.type == token.NAME and first_leaf.value == 'def')
+ or (
+ first_leaf.type == token.NAME
+ and first_leaf.value == 'async'
+ and second_leaf is not None
+ and second_leaf.type == token.NAME
+ and second_leaf.value == 'def'
)
)
@property
def is_flow_control(self) -> bool:
return (
- bool(self) and
- self.leaves[0].type == token.NAME and
- self.leaves[0].value in FLOW_CONTROL
+ bool(self)
+ and self.leaves[0].type == token.NAME
+ and self.leaves[0].value in FLOW_CONTROL
)
@property
def is_yield(self) -> bool:
return (
- bool(self) and
- self.leaves[0].type == token.NAME and
- self.leaves[0].value == 'yield'
+ bool(self)
+ and self.leaves[0].type == token.NAME
+ and self.leaves[0].value == 'yield'
)
def maybe_remove_trailing_comma(self, closing: Leaf) -> bool:
if not (
- self.leaves and
- self.leaves[-1].type == token.COMMA and
- closing.type in CLOSING_BRACKETS
+ self.leaves
+ and self.leaves[-1].type == token.COMMA
+ and closing.type in CLOSING_BRACKETS
):
return False
appended will appear "too long" when splitting.
"""
if not (
- comment.type == STANDALONE_COMMENT and
- self.bracket_tracker.any_open_brackets()
+ comment.type == STANDALONE_COMMENT
+ and self.bracket_tracker.any_open_brackets()
):
return False
"""Provides a stateful method that returns the number of potential extra
empty lines needed before and after the currently processed line.
- Note: this tracker works on lines that haven't been split yet.
+ Note: this tracker works on lines that haven't been split yet. It assumes
+ the prefix of the first leaf consists of optional newlines. Those newlines
+ are consumed by `maybe_empty_lines()` and included in the computation.
"""
previous_line: Optional[Line] = None
previous_after: int = 0
(two on module-level), as well as providing an extra empty line after flow
control keywords to make them more prominent.
"""
+ if current_line.is_comment:
+ # Don't count standalone comments towards previous empty lines.
+ return 0, 0
+
before, after = self._maybe_empty_lines(current_line)
+ before -= self.previous_after
self.previous_after = after
self.previous_line = current_line
return before, after
def _maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
- before = 0
+ if current_line.leaves:
+ # Consume the first leaf's extra newlines.
+ first_leaf = current_line.leaves[0]
+ before = int('\n' in first_leaf.prefix)
+ first_leaf.prefix = ''
+ else:
+ before = 0
depth = current_line.depth
while self.previous_defs and self.previous_defs[-1] >= depth:
self.previous_defs.pop()
- before = (1 if depth else 2) - self.previous_after
+ before = 1 if depth else 2
is_decorator = current_line.is_decorator
if is_decorator or current_line.is_def or current_line.is_class:
if not is_decorator:
newlines = 2
if current_line.depth:
newlines -= 1
- newlines -= self.previous_after
return newlines, 0
if current_line.is_flow_control:
return before, 1
if (
- self.previous_line and
- self.previous_line.is_import and
- not current_line.is_import and
- depth == self.previous_line.depth
+ self.previous_line
+ and self.previous_line.is_import
+ and not current_line.is_import
+ and depth == self.previous_line.depth
):
return (before or 1), 0
if (
- self.previous_line and
- self.previous_line.is_yield and
- (not current_line.is_yield or depth != self.previous_line.depth)
+ self.previous_line
+ and self.previous_line.is_yield
+ and (not current_line.is_yield or depth != self.previous_line.depth)
):
return (before or 1), 0
return NO
elif (
- p.type == syms.listmaker or
- p.type == syms.testlist_gexp or
- p.type == syms.subscriptlist
+ p.type == syms.listmaker
+ or p.type == syms.testlist_gexp
+ or p.type == syms.subscriptlist
):
# list interior, including unpacking
if not prev:
if leaf.type == token.COMMA:
return COMMA_PRIORITY
- if leaf.type == token.NAME and leaf.value in LOGIC_OPERATORS:
- return LOGIC_PRIORITY
-
if leaf.type in COMPARATORS:
return COMPARATOR_PRIORITY
if (
- leaf.type in MATH_OPERATORS and
- leaf.parent and
- leaf.parent.type not in {syms.factor, syms.star_expr}
+ leaf.type in MATH_OPERATORS
+ and leaf.parent
+ and leaf.parent.type not in {syms.factor, syms.star_expr}
):
return MATH_PRIORITY
if content and (content[0] not in {' ', '!', '#'}):
content = ' ' + content
is_standalone_comment = (
- '\n' in before_comment or '\n' in content or leaf.type == token.DEDENT
+ '\n' in before_comment or '\n' in content or leaf.type == token.ENDMARKER
)
if not is_standalone_comment:
# simple trailing comment
matching_bracket = None
for leaf in line.leaves:
if (
- current_leaves is body_leaves and
- leaf.type in CLOSING_BRACKETS and
- leaf.opening_bracket is matching_bracket
+ current_leaves is body_leaves
+ and leaf.type in CLOSING_BRACKETS
+ and leaf.opening_bracket is matching_bracket
):
current_leaves = tail_leaves if body_leaves else head_leaves
current_leaves.append(leaf)
current_line.append(comment_after, preformatted=True)
lowest_depth = min(lowest_depth, leaf.bracket_depth)
if (
- leaf.bracket_depth == lowest_depth and
- leaf.type == token.STAR or
- leaf.type == token.DOUBLESTAR
+ leaf.bracket_depth == lowest_depth
+ and leaf.type == token.STAR
+ or leaf.type == token.DOUBLESTAR
):
trailing_comma_safe = trailing_comma_safe and py36
leaf_priority = delimiters.get(id(leaf))
current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
if current_line:
if (
- delimiter_priority == COMMA_PRIORITY and
- current_line.leaves[-1].type != token.COMMA and
- trailing_comma_safe
+ delimiter_priority == COMMA_PRIORITY
+ and current_line.leaves[-1].type != token.COMMA
+ and trailing_comma_safe
):
current_line.append(Leaf(token.COMMA, ','))
normalize_prefix(current_line.leaves[0])
t = leaf.type
v = leaf.value
return bool(
- t == token.NAME and
- (
- (v == 'import' and p and p.type == syms.import_name) or
- (v == 'from' and p and p.type == syms.import_from)
+ t == token.NAME
+ and (
+ (v == 'import' and p and p.type == syms.import_name)
+ or (v == 'from' and p and p.type == syms.import_from)
)
)
if is_import(leaf):
spl = leaf.prefix.split('#', 1)
nl_count = spl[0].count('\n')
- if len(spl) > 1:
- # Skip one newline since it was for a standalone comment.
- nl_count -= 1
leaf.prefix = '\n' * nl_count
return
return True
elif (
- n.type == syms.typedargslist and
- n.children and
- n.children[-1].type == token.COMMA
+ n.type == syms.typedargslist
+ and n.children
+ and n.children[-1].type == token.COMMA
):
for ch in n.children:
if ch.type == token.STAR or ch.type == token.DOUBLESTAR:
projects / etc / vim.git / blobdiff