//third_party/WebKit clang-format preparation patch

third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp.py

 # -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009, 2010, 2012 Google Inc. All rights reserved.
 # Copyright (C) 2009 Torch Mobile Inc.
 # Copyright (C) 2009 Apple Inc. All rights reserved.
 # Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
@@ skipping 1519 matching lines @@
     # they'll never need to wrap.
     if (  # Ignore control structures.
             not search(r'\b(if|for|foreach|while|switch|return|new|delete)\b', function_call)
             # Ignore pointers/references to functions.
             and not search(r' \([^)]+\)\([^)]*(\)|,$)', function_call)
             # Ignore pointers/references to arrays.
             and not search(r' \([^)]+\)\[[^\]]+\]', function_call)):
         if search(r'\w\s*\([ \t](?!\s*\\$)', function_call):      # a ( used for a fn call
             error(line_number, 'whitespace/parens', 4,
                   'Extra space after ( in function call')
         elif search(r'\([ \t]+(?!(\s*\\)|\()', function_call):

[danakj, 2016/09/29 20:54:04]

All these whitespace things look redundant with the "is the patch
clang-formatted?" check

             error(line_number, 'whitespace/parens', 2,
                   'Extra space after (')
-        if (search(r'\w\s+\(', function_call)
-                and not match(r'\s*(#|typedef)', function_call)):
-            error(line_number, 'whitespace/parens', 4,
-                  'Extra space before ( in function call')
         # If the ) is followed only by a newline or a { + newline, assume it's
         # part of a control statement (if/while/etc), and don't complain
         if search(r'[^)\s]\s+\)(?!\s*$|{\s*$)', function_call):
             error(line_number, 'whitespace/parens', 2,
                   'Extra space before )')
 
 
 def is_blank_line(line):
     """Returns true if the given line is blank.
 
@@ skipping 312 matching lines @@
                 # closing paren, without the opening paren, followed by an opening brace
                 # or colon (for initializer lists) we assume that it is the last line of
                 # a function header.  If we have a colon indented 4 spaces, it is an
                 # initializer list.
                 exception = (match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)',
                                    previous_line)
                              or match(r' {4}:', previous_line))
 
             if not exception:
                 error(line_number, 'whitespace/blank_line', 2,
                       'Blank line at the start of a code block.  Is this needed?')

[danakj, 2016/09/29 20:54:04]

Doesn't clang-format kill these?

[dcheng, 2016/09/29 21:10:58]

(This also applies to the previous comment)
It does, but I'm trying to minimize the number of manual changes we land
alongside the giant reformat. The main goal of these deletions is to make
check-webkit-style not complain about clang-formatted code, not to eliminate all
things that would be redundant with clang-format.

I do plan on cleaning this up after clang-format lands and sticks, I'm just
being very conservative with what's removed for now (since each
check-webkit-style run takes several minutes)

[danakj, 2016/09/29 21:19:56]

okay. Given the complexity here I was not sure if it makes your life easier or
harder to delete a lot more code.

         # This doesn't ignore whitespace at the end of a namespace block
         # because that is too hard without pairing open/close braces;
         # however, a special exception is made for namespace closing
         # brackets which have a comment containing "namespace".
         #
         # Also, ignore blank lines at the end of a block in a long if-else
         # chain, like this:
         #   if (condition1) {
         #     // Something followed by a blank line
         #
         #   } else if (condition2) {
         #     // Something else
         #   }
         if line_number + 1 < clean_lines.num_lines():
             next_line = raw[line_number + 1]
             if next_line and match(r'\s*}', next_line) and 'namespace' not in next_line and '} else ' not in next_line:
                 error(line_number, 'whitespace/blank_line', 3,
                       'Blank line at the end of a code block.  Is this needed?')
 
-    # Next, we check for proper spacing with respect to comments.
-    comment_position = line.find('//')
-    if comment_position != -1:
-        # Check if the // may be in quotes.  If so, ignore it
-        # Comparisons made explicit for clarity
-        if (line.count('"', 0, comment_position) - line.count('\\"', 0, comment_position)) % 2 == 0:   # not in quotes
-            # Allow one space before end of line comment.
-            if (not match(r'^\s*$', line[:comment_position])
-                and (comment_position >= 1
-                     and ((line[comment_position - 1] not in string.whitespace)
-                          or (comment_position >= 2
-                              and line[comment_position - 2] in string.whitespace)))):
-                error(line_number, 'whitespace/comments', 5,
-                      'One space before end of line comments')
-            # There should always be a space between the // and the comment
-            commentend = comment_position + 2
-            if commentend < len(line) and not line[commentend] == ' ':
-                # but some lines are exceptions -- e.g. if they're big
-                # comment delimiters like:
-                # //----------------------------------------------------------
-                # or they begin with multiple slashes followed by a space:
-                # //////// Header comment
-                matched = (search(r'[=/-]{4,}\s*$', line[commentend:])
-                           or search(r'^/+ ', line[commentend:]))
-                if not matched:
-                    error(line_number, 'whitespace/comments', 4,
-                          'Should have a space between // and comment')
-
     line = clean_lines.elided[line_number]  # get rid of comments and strings
 
     # Don't try to do spacing checks for operator methods
     line = sub(r'operator(==|!=|<|<<|<=|>=|>>|>|\+=|-=|\*=|/=|%=|&=|\|=|^=|<<=|>>=|/)\(', 'operator\(', line)
     # Don't try to do spacing checks for #include or #import statements at
     # minimum because it messes up checks for spacing around /
     if match(r'\s*#\s*(?:include|import)', line):
         return
     if search(r'[\w.]=[\w.]', line):
         error(line_number, 'whitespace/operators', 4,
               'Missing spaces around =')

[danakj, 2016/09/29 20:54:04]

..and fix these.. 

I'm inclined to suggest removing all "whitespace/xyz" checks.

 
-    # FIXME: It's not ok to have spaces around binary operators like .
-
-    # You should always have whitespace around binary operators.
-    # Alas, we can't test < or > because they're legitimately used sans spaces
-    # (a->b, vector<int> a).  The only time we can tell is a < with no >, and
-    # only if it's not template params list spilling into the next line.
-    matched = search(r'[^<>=!\s](==|!=|\+=|-=|\*=|/=|/|\|=|&=|<<=|>>=|<=|>=|\|\||\||<<)[^<>=!\s]', line)
-    if not matched:
-        # Note that while it seems that the '<[^<]*' term in the following
-        # regexp could be simplified to '<.*', which would indeed match
-        # the same class of strings, the [^<] means that searching for the
-        # regexp takes linear rather than quadratic time.
-        if not search(r'<[^<]*,\s*$', line):  # template params spill
-            matched = search(r'[^<>=!\s](<)[^<>=!\s]([^>]|->)*$', line)
-    if not matched:
-        # Regardless of template arguments or operator>>, \w should not
-        # follow >>.
-        matched = search(r'(>>)\w', line)
-        # If the line has no template arguments, >> is operator>>.
-        # FIXME: This doesn't handle line-breaks inside template arguments.
-        if not matched and not search(r'<', line):
-            matched = search(r'\w(>>)', line)
-
-    if matched:
-        error(line_number, 'whitespace/operators', 3,
-              'Missing spaces around %s' % matched.group(1))
-
     # There shouldn't be space around unary operators
     matched = search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line)
     if matched:
         error(line_number, 'whitespace/operators', 4,
               'Extra space for operator %s' % matched.group(1))
 
     # A pet peeve of mine: no spaces after an if, while, switch, or for
     matched = search(r' (if\(|for\(|foreach\(|while\(|switch\()', line)
     if matched:
         error(line_number, 'whitespace/parens', 5,
@@ skipping 51 matching lines @@
     elif file_extension == 'c':
         # C Pointer declaration should have the * beside the variable not the type name.
         matched = search(r'^\s*\w+\*\s+\w+', line)
         if matched:
             error(line_number, 'whitespace/declaration', 3,
                   'Declaration has space between * and variable name in %s' % matched.group(0).strip())
 
     # Next we will look for issues with function calls.
     check_spacing_for_function_call(line, line_number, error)
 
-    # Except after an opening paren, you should have spaces before your braces.
-    # And since you should never have braces at the beginning of a line, this is
-    # an easy test.
-    if search(r'[^ ({]{', line):
-        error(line_number, 'whitespace/braces', 5,
-              'Missing space before {')
-
     # Make sure '} else {' has spaces.
     if search(r'}else', line):
         error(line_number, 'whitespace/braces', 5,
               'Missing space before else')
 
     # You shouldn't have spaces before your brackets, except maybe after
     # 'delete []' or 'new char * []'.
     if search(r'\w\s+\[', line) and not search(r'delete\s+\[', line):
         error(line_number, 'whitespace/braces', 5,
               'Extra space before [')
@@ skipping 73 matching lines @@
                   'namespace should never be indented.')
         return
     looking_for_semicolon = False
     line_offset = 0
     in_preprocessor_directive = False
     for current_line in clean_lines.elided[line_number + 1:]:
         line_offset += 1
         if not current_line.strip():
             continue
         if not current_indentation_level:
-            if not (in_preprocessor_directive or looking_for_semicolon):
-                if not match(r'\S', current_line) and not file_state.did_inside_namespace_indent_warning():
-                    file_state.set_did_inside_namespace_indent_warning()
-                    error(line_number + line_offset, 'whitespace/indent', 4,
-                          'Code inside a namespace should not be indented.')
             if in_preprocessor_directive or (current_line.strip()[0] == '#'):  # This takes care of preprocessor directive syntax.
                 in_preprocessor_directive = current_line[-1] == '\\'
             else:
                 looking_for_semicolon = ((';' not in current_line) and (current_line.strip()
                                                                         [-1] != '}')) or (current_line[-1] == '\\')
         else:
             looking_for_semicolon = False  # If we have a brace we may not need a semicolon.
         current_indentation_level += current_line.count('{') - current_line.count('}')
         if current_indentation_level < 0:
             break
 
 
 def check_enum_casing(clean_lines, line_number, enum_state, error):
     """Looks for incorrectly named enum values.
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       enum_state: A _EnumState instance which maintains enum declaration state.
       error: The function to call with any errors found.
     """
 
     line = clean_lines.elided[line_number]  # Get rid of comments and strings.
     if not enum_state.process_clean_line(line):
         error(line_number, 'readability/enum_casing', 4,
               'enum members should use InterCaps with an initial capital letter.')
 
 
-def check_directive_indentation(clean_lines, line_number, file_state, error):
-    """Looks for indentation of preprocessor directives.
-
-    Args:
-      clean_lines: A CleansedLines instance containing the file.
-      line_number: The number of the line to check.
-      file_state: A _FileState instance which maintains information about
-                  the state of things in the file.
-      error: The function to call with any errors found.
-    """
-
-    line = clean_lines.elided[line_number]  # Get rid of comments and strings.
-
-    indented_preprocessor_directives = match(r'\s+#', line)
-    if not indented_preprocessor_directives:
-        return
-
-    error(line_number, 'whitespace/indent', 4, 'preprocessor directives (e.g., #ifdef, #define, #import) should never be indented.')
-
-
 def get_initial_spaces_for_line(clean_line):
     initial_spaces = 0
     while initial_spaces < len(clean_line) and clean_line[initial_spaces] == ' ':
         initial_spaces += 1
     return initial_spaces
 
 
-def check_indentation_amount(clean_lines, line_number, error):
-    line = clean_lines.elided[line_number]
-    initial_spaces = get_initial_spaces_for_line(line)
-
-    if initial_spaces % 4:
-        error(line_number, 'whitespace/indent', 3,
-              'Weird number of spaces at line-start.  Are you using a 4-space indent?')
-        return
-
-    previous_line = get_previous_non_blank_line(clean_lines, line_number)[0]
-    if not previous_line.strip() or match(r'\s*\w+\s*:\s*$', previous_line) or previous_line[0] == '#':
-        return
-
-    previous_line_initial_spaces = get_initial_spaces_for_line(previous_line)
-    if initial_spaces > previous_line_initial_spaces + 4:
-        error(line_number, 'whitespace/indent', 3, 'When wrapping a line, only indent 4 spaces.')
-
-
 def check_using_std(clean_lines, line_number, file_state, error):
     """Looks for 'using std::foo;' statements which should be replaced with 'using namespace std;'.
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       file_state: A _FileState instance which maintains information about
                   the state of things in the file.
       error: The function to call with any errors found.
     """
@@ skipping 83 matching lines @@
 
     switch_match = match(r'(?P<switch_indentation>\s*)switch\s*\(.+\)\s*{\s*$', line)
     if not switch_match:
         return
 
     switch_indentation = switch_match.group('switch_indentation')
     inner_indentation = switch_indentation + ' ' * 4
     line_offset = 0
     encountered_nested_switch = False
 
     for current_line in clean_lines.elided[line_number + 1:]:

[danakj, 2016/09/29 20:54:04]

This whole loop has no errors left so it could all go away?

[dcheng, 2016/09/29 21:10:58]

Done.

         line_offset += 1
 
         # Skip not only empty lines but also those with preprocessor directives.
         if current_line.strip() == '' or current_line.startswith('#'):
             continue
 
         if match(r'\s*switch\s*\(.+\)\s*{\s*$', current_line):
             # Complexity alarm - another switch statement nested inside the one
             # that we're currently testing. We'll need to track the extent of
             # that inner switch if the upcoming label tests are still supposed
             # to work correctly. Let's not do that; instead, we'll finish
             # checking this line, and then leave it like that. Assuming the
             # indentation is done consistently (even if incorrectly), this will
             # still catch all indentation issues in practice.
             encountered_nested_switch = True
 
         current_indentation_match = match(r'(?P<indentation>\s*)(?P<remaining_line>.*)$', current_line)
         current_indentation = current_indentation_match.group('indentation')
         remaining_line = current_indentation_match.group('remaining_line')
 
         # End the check at the end of the switch statement.
         if remaining_line.startswith('}') and current_indentation == switch_indentation:
             break
-        # Case and default branches should not be indented. The regexp also
-        # catches single-line cases like "default: break;" but does not trigger
-        # on stuff like "Document::Foo();".
-        elif match(r'(default|case\s+.*)\s*:([^:].*)?$', remaining_line):
-            if current_indentation != switch_indentation:
-                error(line_number + line_offset, 'whitespace/indent', 4,
-                      'A case label should not be indented, but line up with its switch statement.')
-                # Don't throw an error for multiple badly indented labels,
-                # one should be enough to figure out the problem.
-                break
         # We ignore goto labels at the very beginning of a line.
         elif match(r'\w+\s*:\s*$', remaining_line):
             continue
-        # It's not a goto label, so check if it's indented at least as far as
-        # the switch statement plus one more level of indentation.
-        elif not current_indentation.startswith(inner_indentation):
-            error(line_number + line_offset, 'whitespace/indent', 4,
-                  'Non-label code inside switch statements should be indented.')
-            # Don't throw an error for multiple badly indented statements,
-            # one should be enough to figure out the problem.
-            break
 
         if encountered_nested_switch:
             break
 
 
 def check_braces(clean_lines, line_number, error):
     """Looks for misplaced braces (e.g. at the end of line).
 
     Args:
       clean_lines: A CleansedLines instance containing the file.
       line_number: The number of the line to check.
       error: The function to call with any errors found.
     """
 
     line = clean_lines.elided[line_number]  # Get rid of comments and strings.
 
-    if match(r'\s*{\s*$', line):
-        # We allow an open brace to start a line in the case where someone
-        # is using braces for function definition or in a block to
-        # explicitly create a new scope, which is commonly used to control
-        # the lifetime of stack-allocated variables.  We don't detect this
-        # perfectly: we just don't complain if the last non-whitespace
-        # character on the previous non-blank line is ';', ':', '{', '}',
-        # ')' or is like a function declaration, and doesn't begin with
-        # 'if|for|while|switch|else' without a beginning '{'.
-        # We also allow '#' for #endif and '=' for array initialization.
-        previous_line = get_previous_non_blank_line(clean_lines, line_number)[0]
-        if ((not search(r'[;:}{)=]\s*$|\)\s*((const|override|final)\s*)*\s*(->\s*.+)?$', previous_line)
-             or search(r'^\s*\b(if|for|foreach|while|switch|else)\b.*[^{]\s*$', previous_line))
-                and previous_line.find('#') < 0):
-            error(line_number, 'whitespace/braces', 4,
-                  'This { should be at the end of the previous line')
-    elif (search(r'\)\s*(((const|override|final)\s*)*\s*)?{\s*$', line)
-          and line.count('(') == line.count(')')
-          and not search(r'\b(if|for|foreach|while|switch)\b', line)
-          and not match(r'\s+[A-Z_][A-Z_0-9]+\b', line)):
-        error(line_number, 'whitespace/braces', 4,
-              'Place brace on its own line for function definitions.')
-
-    # An else clause should be on the same line as the preceding closing brace.
-    if match(r'\s*else\s*', line):
-        previous_line = get_previous_non_blank_line(clean_lines, line_number)[0]
-        if match(r'\s*}\s*$', previous_line):
-            error(line_number, 'whitespace/newline', 4,
-                  'An else should appear on the same line as the preceding }')
-
-    # Likewise, an else should never have the else clause on the same line
-    if search(r'\belse [^\s{]', line) and not search(r'\belse if\b', line):
-        error(line_number, 'whitespace/newline', 4,
-              'Else clause should never be on same line as else (use 2 lines)')
-
-    # In the same way, a do/while should never be on one line
-    if match(r'\s*do [^\s{]', line):
-        error(line_number, 'whitespace/newline', 4,
-              'do/while clauses should not be on a single line')
-
     # Braces shouldn't be followed by a ; unless they're defining a struct
     # or initializing an array.
     # We can't tell in general, but we can for some common cases.
     previous_line_number = line_number
     while True:
         (previous_line, previous_line_number) = get_previous_non_blank_line(clean_lines, previous_line_number)
         if match(r'\s+{.*}\s*;', line) and not previous_line.count(';'):
             line = previous_line + line
         else:
             break
@@ skipping 486 matching lines @@
 
     if '\t' in line:
         error(line_number, 'whitespace/tab', 1,
               'Tab found; better to use spaces')
 
     cleansed_line = clean_lines.elided[line_number]
     if line and line[-1].isspace():
         error(line_number, 'whitespace/end_of_line', 4,
               'Line ends in whitespace.  Consider deleting these extra spaces.')
 
-    if (cleansed_line.count(';') > 1
-        # for loops are allowed two ;'s (and may run over two lines).
-        and 'for' not in cleansed_line
-        and (get_previous_non_blank_line(clean_lines, line_number)[0].find('for') == -1
-             or get_previous_non_blank_line(clean_lines, line_number)[0].find(';') != -1)
-        # It's ok to have many commands in a switch case that fits in 1 line
-        and not (('case ' in cleansed_line
-                  or 'default:' in cleansed_line)
-                 and 'break;' in cleansed_line)
-        # Also it's ok to have many commands in trivial single-line accessors in class definitions.
-        and not (match(r'.*\(.*\).*{.*.}', line)
-                 and class_state.classinfo_stack
-                 and line.count('{') == line.count('}'))
-        and not cleansed_line.startswith('#define ')
-        # It's ok to use use WTF_MAKE_NONCOPYABLE and WTF_MAKE_FAST_ALLOCATED macros in 1 line
-        and not (cleansed_line.find("WTF_MAKE_NONCOPYABLE") != -1
-                 and cleansed_line.find("WTF_MAKE_FAST_ALLOCATED") != -1)):
-        error(line_number, 'whitespace/newline', 4,
-              'More than one command on the same line')
-
-    if cleansed_line.strip().endswith('||') or cleansed_line.strip().endswith('&&'):
-        error(line_number, 'whitespace/operators', 4,
-              'Boolean expressions that span multiple lines should have their '
-              'operators on the left side of the line instead of the right side.')
-
     # Some more style checks
     check_namespace_indentation(clean_lines, line_number, file_extension, file_state, error)
-    check_directive_indentation(clean_lines, line_number, file_state, error)
     check_using_std(clean_lines, line_number, file_state, error)
     check_max_min_macros(clean_lines, line_number, file_state, error)
     check_ctype_functions(clean_lines, line_number, file_state, error)
     check_switch_indentation(clean_lines, line_number, error)
     check_braces(clean_lines, line_number, error)
     check_exit_statement_simplifications(clean_lines, line_number, error)
     check_spacing(file_extension, clean_lines, line_number, error)
     check_check(clean_lines, line_number, error)
     check_deprecated_macros(clean_lines, line_number, error)
     check_for_comparisons_to_boolean(clean_lines, line_number, error)
     check_for_null(clean_lines, line_number, file_state, error)
-    check_indentation_amount(clean_lines, line_number, error)
     check_enum_casing(clean_lines, line_number, enum_state, error)
 
 
 _RE_PATTERN_INCLUDE_NEW_STYLE = re.compile(r'#include +"[^/]+\.h"')
 _RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$')
 # Matches the first component of a filename delimited by -s and _s. That is:
 #  _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo'
 #  _RE_FIRST_COMPONENT.match('foo.cpp').group(0) == 'foo'
 #  _RE_FIRST_COMPONENT.match('foo-bar_baz.cpp').group(0) == 'foo'
 #  _RE_FIRST_COMPONENT.match('foo_bar-baz.cpp').group(0) == 'foo'
@@ skipping 1140 matching lines @@
         'runtime/references',
         'runtime/rtti',
         'runtime/sizeof',
         'runtime/string',
         'runtime/threadsafe_fn',
         'runtime/unsigned',
         'runtime/virtual',
         'whitespace/blank_line',
         'whitespace/braces',
         'whitespace/comma',
-        'whitespace/comments',
         'whitespace/declaration',
         'whitespace/end_of_line',
         'whitespace/ending_newline',
         'whitespace/indent',
         'whitespace/line_length',
-        'whitespace/newline',
         'whitespace/operators',
         'whitespace/parens',
         'whitespace/semicolon',
         'whitespace/tab',
         'whitespace/todo',
     ])
 
     fs = None
 
     def __init__(self, file_path, file_extension, handle_style_error,
@@ skipping 31 matching lines @@
 
     def check(self, lines):
         _process_lines(self.file_path, self.file_extension, lines,
                        self.handle_style_error, self.min_confidence)
 
 
 # FIXME: Remove this function (requires refactoring unit tests).
 def process_file_data(filename, file_extension, lines, error, min_confidence, fs=None):
     checker = CppChecker(filename, file_extension, error, min_confidence, fs)
     checker.check(lines)