Update the static_cast style check to check for DEFINE_TYPE_CASTS patterns as well.

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 3393 matching lines @@
         # We should continue checking if this is a function
         # declaration because we need to check its arguments.
         # Also, we need to check multiple declarations.
         if character_after_identifier != '(' and character_after_identifier != ',':
             return
 
         number_of_identifiers += 1
         line = line[matched.end():]
 
 
-def check_for_toFoo_definition(filename, pattern, error):
-    """ Reports for using static_cast instead of toFoo convenience function.
+_RE_GENERAL_MACRO_PATTERN_STRING = None
+_RE_EXPLICIT_FUNCTION_PATTERN_STRING = None
 
-    This function will output warnings to make sure you are actually using
-    the added toFoo conversion functions rather than directly hard coding
-    the static_cast<Classname*> call. For example, you should toHTMLELement(Node*)
-    to convert Node* to HTMLElement*, instead of static_cast<HTMLElement*>(Node*)
+
+def check_for_toFoo_definition(filename, search_function_name, error):
+    """Checks for a Cpp-style static cast on objects by searching for the pattern.
 
     Args:
       filename: The name of the header file in which to check for toFoo definition.
-      pattern: The conversion function pattern to grep for.
+      search_function_name: The toFoo convenience function string.
       error: The function to call with any errors found.
     """
     def get_abs_filepath(filename):
         fileSystem = FileSystem()
         base_dir = fileSystem.path_to_module(FileSystem.__module__).split('WebKit', 1)[0]
         base_dir = ''.join((base_dir, 'WebKit/Source'))
         for root, dirs, names in os.walk(base_dir):
             if filename in names:
                 return os.path.join(root, filename)
         return None
 
-    def grep(lines, pattern, error):
+    def grep(lines, search_function_name, error):
         matches = []
         function_state = None
         for line_number in xrange(lines.num_lines()):
             line = (lines.elided[line_number]).rstrip()
             try:
-                if pattern in line:
+                if re.search(_RE_GENERAL_MACRO_PATTERN_STRING, line):
+                    # Search for DEFINE_TYPE_CASTS macro pattern in the source header.
+                    matches.append([line, line_number + 1, line_number + 1])
+                elif re.search(_RE_EXPLICIT_FUNCTION_PATTERN_STRING, line):
+                    # DEFINE_TYPE_CASTS macro pattern not found in source header.
+                    # Instead, search for toFoo() function pattern in source header.
                     if not function_state:
                         function_state = _FunctionState(1)
                     detect_functions(lines, line_number, function_state, error)
                     # Exclude the match of dummy conversion function. Dummy function is just to
                     # catch invalid conversions and shouldn't be part of possible alternatives.
-                    result = re.search(r'%s(\s+)%s' % ("void", pattern), line)
+                    result = re.search(r'%s(\s+)%s' % ("void", search_function_name), line)
                     if not result:
                         matches.append([line, function_state.body_start_position.row, function_state.end_position.row + 1])
                         function_state = None
             except UnicodeDecodeError:
                 # There would be no non-ascii characters in the codebase ever. The only exception
                 # would be comments/copyright text which might have non-ascii characters. Hence,
                 # it is prefectly safe to catch the UnicodeDecodeError and just pass the line.
                 pass
 
         return matches
@@ skipping 25 matching lines @@
     file_path = get_abs_filepath(filename)
     if not file_path:
         return None
     try:
         f = open(file_path)
         clean_lines = CleansedLines(f.readlines())
     finally:
         f.close()
 
     # Make a list of all genuine alternatives to static_cast.
-    matches = grep(clean_lines, pattern, error)
+    matches = grep(clean_lines, search_function_name, error)
     return matches
 
 
 def check_for_object_static_cast(processing_file, line_number, line, error):
-    """Checks for a Cpp-style static cast on objects by looking for the pattern.
+    """ Reports for using static_cast instead of toFoo convenience function.
+
+    This function will output warnings to make sure you are actually using
+    the added toFoo conversion functions rather than directly hard coding
+    the static_cast<Classname*> call. For example, you should toHTMLELement(Node*)
+    to convert Node* to HTMLElement*, instead of static_cast<HTMLElement*>(Node*)
 
     Args:
       processing_file: The name of the processing file.
       line_number: The number of the line to check.
       line: The line of code to check.
       error: The function to call with any errors found.
     """
+
     matched = search(r'\bstatic_cast<(\s*\w*:?:?\w+\s*\*+\s*)>', line)
     if not matched:
         return
 
     class_name = re.sub('[\*]', '', matched.group(1))
     class_name = class_name.strip()
     # Ignore (for now) when the casting is to void*,
     if class_name == 'void':
         return
 
     namespace_pos = class_name.find(':')
     if not namespace_pos == -1:
         class_name = class_name[namespace_pos + 2:]
 
     header_file = ''.join((class_name, '.h'))
-    matches = check_for_toFoo_definition(header_file, ''.join(('to', class_name)), error)
-    # Ignore (for now) if not able to find the header where toFoo might be defined.
-    # TODO: Handle cases where Classname might be defined in some other header or cpp file.
+    toFoo_name = ''.join(('to', class_name))
+    _RE_GENERAL_MACRO_PATTERN_STRING = re.compile(r'\s*DEFINE_(\w*)TYPE_CASTS\(%s,(.+)(\);$)' % class_name)

[sof, 2014/02/05 13:26:47]

Doesn't this need a 'global' to be able to work as intended?

+    _RE_EXPLICIT_FUNCTION_PATTERN_STRING = re.compile(r'[ \w]*%s\*\s+%s\((.+)\)$' % (class_name, toFoo_name))
+    matches = check_for_toFoo_definition(header_file, toFoo_name, error)
+
+    # FIXME: Handle cases where Classname might be defined in some other header or cpp file.
+    # It will ensure check_for_toFoo_definition nevers 'None' and we can remove this unneccessary check.
     if matches is None:
         return
 
     report_error = True
     # Ensure found static_cast instance is not from within toFoo definition itself.
     if (os.path.basename(processing_file) == header_file):
         for item in matches:
             if line_number in range(item[1], item[2]):
                 report_error = False
                 break
 
     if report_error:
         if len(matches):
             # toFoo is defined - enforce using it.
-            # TODO: Suggest an appropriate toFoo from the alternatives present in matches.
-            error(line_number, 'runtime/casting', 4,
+            # FIXME: Suggest an appropriate toFoo from the alternatives present in matches.
+            error(line_number, 'security/casting', 4,
                   'static_cast of class objects is not allowed. Use to%s defined in %s.' %
                   (class_name, header_file))
         else:
             # No toFoo defined - enforce definition & usage.
-            # TODO: Automate the generation of toFoo() to avoid any slippages ever.
             error(line_number, 'runtime/casting', 4,
-                  'static_cast of class objects is not allowed. Add to%s in %s and use it instead.' %
+                  'static_cast of class objects is not allowed. Define cast macro DEFINE_TYPE_CASTS(%s) in %s and use it.' %
                   (class_name, header_file))
 
 
 def check_c_style_cast(line_number, line, raw_line, cast_type, pattern,
                        error):
     """Checks for a C-style cast by looking for the pattern.
 
     This also handles sizeof(type) warnings, due to similarity of content.
 
     Args:
@@ skipping 419 matching lines @@
         'runtime/memset',
         'runtime/printf',
         'runtime/printf_format',
         'runtime/references',
         'runtime/rtti',
         'runtime/sizeof',
         'runtime/string',
         'runtime/threadsafe_fn',
         'runtime/unsigned',
         'runtime/virtual',
+        'security/casting',
         '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',
@@ skipping 42 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)