blink: Remove include ordering checks, clang-format does this now.

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 100 matching lines @@
     ['ASSERT', 'DCHECK or its variants'],
     ['ASSERT_UNUSED', 'DCHECK or its variants'],
     ['ASSERT_NOT_REACHED', 'NOTREACHED'],
     ['WTF_LOG', 'DVLOG']
 ]
 
 # These constants define types of headers for use with
 # _IncludeState.check_next_include_order().
 _PRIMARY_HEADER = 0
 _OTHER_HEADER = 1
-_MOC_HEADER = 2
 
 
 # The regexp compilation caching is inlined in all regexp functions for
 # performance reasons; factoring it out into a separate function turns out
 # to be noticeably expensive.
 _regexp_compile_cache = {}
 
 
 def match(pattern, s):
     """Matches the string with the pattern, caching the compiled regexp."""
@@ skipping 168 matching lines @@
     """
     # self._section will move monotonically through this set. If it ever
     # needs to move backwards, check_next_include_order will raise an error.
     _INITIAL_SECTION = 0
     _PRIMARY_SECTION = 1
     _OTHER_SECTION = 2
 
     _TYPE_NAMES = {
         _PRIMARY_HEADER: 'header this file implements',
         _OTHER_HEADER: 'other header',
-        _MOC_HEADER: 'moc file',
     }
     _SECTION_NAMES = {
         _INITIAL_SECTION: "... nothing.",
         _PRIMARY_SECTION: 'a header this file implements.',
         _OTHER_SECTION: 'other header.',
     }
 
     def __init__(self):
         dict.__init__(self)
         self._section = self._INITIAL_SECTION
@@ skipping 12 matching lines @@
         Args:
           header_type: One of the _XXX_HEADER constants defined above.
           file_is_header: Whether the file that owns this _IncludeState is itself a header
 
         Returns:
           The empty string if the header is in the right order, or an
           error message describing what's wrong.
         """
         if header_type == _PRIMARY_HEADER and file_is_header:
             return 'Header file should not contain itself.'
-        if header_type == _MOC_HEADER:
-            return ''
 
         error_message = ''
         if self._section != self._OTHER_SECTION:
             before_error_message = ('Found %s before %s' %
                                     (self._TYPE_NAMES[header_type],
                                      self._SECTION_NAMES[self._section + 1]))
         after_error_message = ('Found %s after %s' %
                                (self._TYPE_NAMES[header_type],
                                 self._SECTION_NAMES[self._section]))
 
@@ skipping 2077 matching lines @@
     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_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'
 _RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+')
 
 
 def _drop_common_suffixes(filename):
@@ skipping 45 matching lines @@
     # If it is a system header we know it is classified as _OTHER_HEADER.
     if is_system and not include.startswith('public/'):
         return _OTHER_HEADER
 
     # There cannot be primary includes in header files themselves. Only an
     # include exactly matches the header filename will be is flagged as
     # primary, so that it triggers the "don't include yourself" check.
     if filename.endswith('.h') and filename != include:
         return _OTHER_HEADER
 
-    # Qt's moc files do not follow the naming and ordering rules, so they should be skipped
-    if include.startswith('moc_') and include.endswith('.cpp'):
-        return _MOC_HEADER
-
-    if include.endswith('.moc'):
-        return _MOC_HEADER
-
     # If the target file basename starts with the include we're checking
     # then we consider it the primary header.
     target_base = FileInfo(filename).base_name()
     include_base = FileInfo(include).base_name()
 
     # If we haven't encountered a primary header, then be lenient in checking.
     if not include_state.visited_primary_section():
         if target_base.find(include_base) != -1:
             return _PRIMARY_HEADER
-        # Qt private APIs use _p.h suffix.
-        if include_base.find(target_base) != -1 and include_base.endswith('_p'):
-            return _PRIMARY_HEADER
 
     # If we already encountered a primary header, perform a strict comparison.
     # In case the two filename bases are the same then the above lenient check
     # probably was a false positive.
     elif include_state.visited_primary_section() and target_base == include_base:
-        if include == "ResourceHandleWin.h":
-            # FIXME: Thus far, we've only seen one example of these, but if we
-            # start to see more, please consider generalizing this check
-            # somehow.
-            return _OTHER_HEADER
         return _PRIMARY_HEADER
 
     return _OTHER_HEADER
 
 
 def _does_primary_header_exist(filename):
     """Return a primary header file name for a file, or empty string
     if the file is not source file or primary header does not exist.
     """
     fileinfo = FileInfo(filename)
@@ skipping 72 matching lines @@
                                                            file_extension == "h",
                                                            primary_header_exists)
 
     # Check to make sure we have a blank line after primary header.
     if not error_message and header_type == _PRIMARY_HEADER:
         next_line = clean_lines.raw_lines[line_number + 1]
         if not is_blank_line(next_line):
             error(line_number, 'build/include_order', 4,
                   'You should add a blank line after implementation file\'s own header.')
 
-    # Check to make sure all headers besides the primary header are
-    # alphabetically sorted. Skip Qt's moc files.
-    if not error_message and header_type == _OTHER_HEADER:
-        previous_line_number = line_number - 1
-        previous_line = clean_lines.lines[previous_line_number]
-        previous_match = _RE_PATTERN_INCLUDE.search(previous_line)
-        while (not previous_match and previous_line_number > 0
-               and not search(r'\A(#if|#ifdef|#ifndef|#else|#elif|#endif)', previous_line)):
-            previous_line_number -= 1
-            previous_line = clean_lines.lines[previous_line_number]
-            previous_match = _RE_PATTERN_INCLUDE.search(previous_line)
-        if previous_match:
-            previous_header_type = include_state.header_types[previous_line_number]
-            if previous_header_type == _OTHER_HEADER and previous_line.strip() > line.strip():
-                # This type of error is potentially a problem with this line or the previous one,
-                # so if the error is filtered for one line, report it for the next. This is so that
-                # we properly handle patches, for which only modified lines produce errors.
-                if not error(line_number - 1, 'build/include_order', 4, 'Alphabetical sorting problem.'):
-                    error(line_number, 'build/include_order', 4, 'Alphabetical sorting problem.')
-
     if error_message:
         if file_extension == 'h':
             error(line_number, 'build/include_order', 4,
                   '%s Should be: alphabetically sorted.' %
                   error_message)
         else:
             error(line_number, 'build/include_order', 4,
                   '%s Should be: primary header, blank line, and then alphabetically sorted.' %
                   error_message)
 
@@ skipping 978 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)