Function CheckBracesSpacing

tools/cpplint.py:4619–4714

Checks for horizontal spacing near commas. Args: filename: The name of the current file. clean_lines: A CleansedLines instance containing the file. linenum: The number of the line to check. nesting_state: A NestingState instance which maintains information about

(filename, clean_lines, linenum, nesting_state, error)

def CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error):
    """Checks for horizontal spacing near commas.

    Args:
      filename: The name of the current file.
      clean_lines: A CleansedLines instance containing the file.
      linenum: The number of the line to check.
      nesting_state: A NestingState instance which maintains information about
                     the current stack of nested blocks being parsed.
      error: The function to call with any errors found.
    """
    line = clean_lines.elided[linenum]

    # Except after an opening paren, or after another opening brace (in case of
    # an initializer list, for instance), you should have spaces before your
    # braces when they are delimiting blocks, classes, namespaces etc.
    # And since you should never have braces at the beginning of a line,
    # this is an easy test.  Except that braces used for initialization don't
    # follow the same rule; we often don't want spaces before those.

    if match := re.match(r"^(.*[^ ({>]){", line):
        # Try a bit harder to check for brace initialization.  This
        # happens in one of the following forms:
        #   Constructor() : initializer_list_{} { ... }
        #   Constructor{}.MemberFunction()
        #   Type variable{};
        #   FunctionCall(type{}, ...);
        #   LastArgument(..., type{});
        #   LOG(INFO) << type{} << " ...";
        #   map_of_type[{...}] = ...;
        #   ternary = expr ? new type{} : nullptr;
        #   OuterTemplate<InnerTemplateConstructor<Type>{}>
        #
        # We check for the character following the closing brace, and
        # silence the warning if it's one of those listed above, i.e.
        # "{.;,)<>]:".
        #
        # To account for nested initializer list, we allow any number of
        # closing braces up to "{;,)<".  We can't simply silence the
        # warning on first sight of closing brace, because that would
        # cause false negatives for things that are not initializer lists.
        #   Silence this:         But not this:
        #     Outer{                if (...) {
        #       Inner{...}            if (...){  // Missing space before {
        #     };                    }
        #
        # There is a false negative with this approach if people inserted
        # spurious semicolons, e.g. "if (cond){};", but we will catch the
        # spurious semicolon with a separate check.
        leading_text = match.group(1)
        (endline, endlinenum, endpos) = CloseExpression(clean_lines, linenum, len(match.group(1)))
        trailing_text = ""
        if endpos > -1:
            trailing_text = endline[endpos:]
        for offset in range(endlinenum + 1, min(endlinenum + 3, clean_lines.NumLines() - 1)):
            trailing_text += clean_lines.elided[offset]
        # We also suppress warnings for `uint64_t{expression}` etc., as the style
        # guide recommends brace initialization for integral types to avoid