third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp.py - Issue 2366153002: //third_party/WebKit clang-format preparation patch

Unified Diff: third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp.py

Issue 2366153002: //third_party/WebKit clang-format preparation patch (Closed)

Patch Set: Created 4 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« third_party/WebKit/Source/core/layout/ng/.clang-format ('K') | « third_party/WebKit/Source/platform/scheduler/.clang-format ('k') | third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

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

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp.py b/third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp.py

index 2efad3274b4ef7b6445b715fce2487f7150b1ab2..07580fb081a4d67cbcd6cc7b2bfb6881fe74b29a 100644

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

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

@@ -1540,10 +1540,6 @@ def check_spacing_for_function_call(line, line_number, error):

elif search(r'$[ \t]+(?!(\s*\$|\()', function_call):

danakj 2016/09/29 20:54:04 All these whitespace things look redundant with th

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):

@@ -1896,34 +1892,6 @@ def check_spacing(file_extension, clean_lines, line_number, error):

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

@@ -1936,33 +1904,6 @@ def check_spacing(file_extension, clean_lines, line_number, error):

error(line_number, 'whitespace/operators', 4,

'Missing spaces around =')

danakj 2016/09/29 20:54:04 ..and fix these.. I'm inclined to suggest removi

- # 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:

@@ -2034,13 +1975,6 @@ def check_spacing(file_extension, clean_lines, line_number, error):

# 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,

@@ -2134,11 +2068,6 @@ def check_namespace_indentation(clean_lines, line_number, file_extension, file_s

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:

@@ -2167,26 +2096,6 @@ def check_enum_casing(clean_lines, line_number, enum_state, error):

'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] == ' ':

@@ -2194,24 +2103,6 @@ def get_initial_spaces_for_line(clean_line):

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;'.

@@ -2339,27 +2230,9 @@ def check_switch_indentation(clean_lines, line_number, error):

# 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

@@ -2376,46 +2249,6 @@ def check_braces(clean_lines, line_number, error):

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.

@@ -2922,34 +2755,8 @@ def check_style(clean_lines, line_number, file_extension, class_state, file_stat

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)

@@ -2961,7 +2768,6 @@ def check_style(clean_lines, line_number, file_extension, class_state, file_stat

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)

@@ -4122,13 +3928,11 @@ class CppChecker(object):

'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',