Remove header ordering checks from check-webkit-style

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 96 matching lines @@
     _CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement
     _CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement
 
 _DEPRECATED_MACROS = [
     ['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
-
 
 # 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."""
     if not pattern in _regexp_compile_cache:
@@ skipping 153 matching lines @@
             if i == 0:
                 return s[:pos], s[pos + 1:]
     return None, None
 
 
 class _IncludeState(dict):
     """Tracks line numbers for includes, and the order in which includes appear.
 
     As a dict, an _IncludeState object serves as a mapping between include
     filename and line number on which that file was included.
-
-    Call check_next_include_order() once for each header in the file, passing
-    in the type constants defined above. Calls in an illegal order will
-    raise an _IncludeError with an appropriate error message.
     """
     # 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',
-    }
     _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
         self._visited_primary_section = False
         self.header_types = dict()
 
     def visited_primary_section(self):
         return self._visited_primary_section
 
-    def check_next_include_order(self, header_type, file_is_header, primary_header_exists):
-        """Returns a non-empty error message if the next header is out of order.
-
-        This function also updates the internal state to be ready to check
-        the next include.
-
-        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.'
-
-        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]))
-
-        if header_type == _PRIMARY_HEADER:
-            if self._section >= self._PRIMARY_SECTION:
-                error_message = after_error_message
-            self._section = self._PRIMARY_SECTION
-            self._visited_primary_section = True
-        else:
-            assert header_type == _OTHER_HEADER
-            if not file_is_header and self._section < self._PRIMARY_SECTION:
-                if primary_header_exists:
-                    error_message = before_error_message
-            self._section = self._OTHER_SECTION
-
-        return error_message
-
 
 class Position(object):
     """Holds the position of something."""
 
     def __init__(self, row, column):
         self.row = row
         self.column = column
 
     def __str__(self):
         return '(%s, %s)' % (self.row, self.column)
@@ skipping 2048 matching lines @@
 
 _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):
-    """Drops common suffixes like _test.cpp or -inl.h from filename.
-
-    For example:
-      >>> _drop_common_suffixes('foo/foo-inl.h')
-      'foo/foo'
-      >>> _drop_common_suffixes('foo/bar/foo.cpp')
-      'foo/bar/foo'
-      >>> _drop_common_suffixes('foo/foo_internal.h')
-      'foo/foo'
-      >>> _drop_common_suffixes('foo/foo_unusualinternal.h')
-      'foo/foo_unusualinternal'
-
-    Args:
-      filename: The input filename.
-
-    Returns:
-      The filename with the common suffix removed.
-    """
-    for suffix in ('test.cpp', 'regtest.cpp', 'unittest.cpp',
-                   'inl.h', 'impl.h', 'internal.h'):
-        if (filename.endswith(suffix) and len(filename) > len(suffix)
-                and filename[-len(suffix) - 1] in ('-', '_')):
-            return filename[:-len(suffix) - 1]
-    return os.path.splitext(filename)[0]
-
-
-def _classify_include(filename, include, is_system, include_state):
-    """Figures out what kind of header 'include' is.
-
-    Args:
-      filename: The current file cpp_style is running over.
-      include: The path to a #included file.
-      is_system: True if the #include used <> rather than "".
-      include_state: An _IncludeState instance in which the headers are inserted.
-
-    Returns:
-      One of the _XXX_HEADER constants.
-
-    For example:
-      >>> _classify_include('foo.cpp', 'foo.h', False)
-      _PRIMARY_HEADER
-      >>> _classify_include('foo.cpp', 'bar.h', False)
-      _OTHER_HEADER
-    """
-
-    # 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
-
-    # 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
-
-    # 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:
-        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)
-    if not fileinfo.is_source():
-        return False
-    primary_header = fileinfo.no_extension() + '.h'
-    return os.path.isfile(primary_header)
-
-
 def check_include_line(filename, file_extension, clean_lines, line_number, include_state, error):
     """Check rules that are applicable to #include lines.
 
     Strings on #include lines are NOT removed from elided line, to make
     certain tasks easier. However, to prevent false positives, checks
     applicable to #include lines in CheckLanguage must be put here.
 
     Args:
       filename: The name of the current file.
       file_extension: The current file extension, without the leading dot.
@@ skipping 32 matching lines @@
               'cc includes should be "CCFoo.h" instead of "cc/CCFoo.h".')
 
     duplicate_header = include in include_state
     if duplicate_header:
         error(line_number, 'build/include', 4,
               '"%s" already included at %s:%s' %
               (include, filename, include_state[include]))
     else:
         include_state[include] = line_number
 
-    header_type = _classify_include(filename, include, is_system, include_state)
-    primary_header_exists = _does_primary_header_exist(filename)
-    include_state.header_types[line_number] = header_type
-
-    # Only proceed if this isn't a duplicate header.
-    if duplicate_header:
-        return
-
-    # We want to ensure that headers appear in the right order:
-    # 1) for implementation files: primary header, blank line, alphabetically sorted
-    # 2) for header files: alphabetically sorted
-    # The include_state object keeps track of the last type seen
-    # and complains if the header types are out of order or missing.
-    error_message = include_state.check_next_include_order(header_type,
-                                                           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.')
-
-    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)
-
 
 def check_language(filename, clean_lines, line_number, file_extension, include_state,
                    file_state, error):
     """Checks rules from the 'C++ language rules' section of cppguide.html.
 
     Some of these rules are hard to test (function overloading, using
     uint32 inappropriately), but we do the best we can.
 
     Args:
       filename: The name of the current file.
@@ skipping 968 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)