cc/PRESUBMIT.py

   1 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 """Top-level presubmit script for cc.
   6
   7 See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
   8 for more details about the presubmit API built into depot_tools.
   9 """
  10
  11 import re
  12 import string
  13
  14 CC_SOURCE_FILES=(r'^cc[\\/].*\.(cc|h)$',)
  15
  16 def CheckChangeLintsClean(input_api, output_api):
  17   source_filter = lambda x: input_api.FilterSourceFile(
  18     x, white_list=CC_SOURCE_FILES, black_list=None)
  19
  20   return input_api.canned_checks.CheckChangeLintsClean(
  21       input_api, output_api, source_filter, lint_filters=[], verbose_level=1)
  22
  23 def CheckAsserts(input_api, output_api, white_list=CC_SOURCE_FILES, black_list=None):
  24   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
  25   source_file_filter = lambda x: input_api.FilterSourceFile(x, white_list, black_list)
  26
  27   assert_files = []
  28   notreached_files = []
  29
  30   for f in input_api.AffectedSourceFiles(source_file_filter):
  31     contents = input_api.ReadFile(f, 'rb')
  32     # WebKit ASSERT() is not allowed.
  33     if re.search(r"\bASSERT\(", contents):
  34       assert_files.append(f.LocalPath())
  35     # WebKit ASSERT_NOT_REACHED() is not allowed.
  36     if re.search(r"ASSERT_NOT_REACHED\(", contents):
  37       notreached_files.append(f.LocalPath())
  38
  39   if assert_files:
  40     return [output_api.PresubmitError(
  41       'These files use ASSERT instead of using DCHECK:',
  42       items=assert_files)]
  43   if notreached_files:
  44     return [output_api.PresubmitError(
  45       'These files use ASSERT_NOT_REACHED instead of using NOTREACHED:',
  46       items=notreached_files)]
  47   return []
  48
  49 def CheckStdAbs(input_api, output_api,
  50                 white_list=CC_SOURCE_FILES, black_list=None):
  51   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
  52   source_file_filter = lambda x: input_api.FilterSourceFile(x,
  53                                                             white_list,
  54                                                             black_list)
  55
  56   using_std_abs_files = []
  57   found_fabs_files = []
  58   missing_std_prefix_files = []
  59
  60   for f in input_api.AffectedSourceFiles(source_file_filter):
  61     contents = input_api.ReadFile(f, 'rb')
  62     if re.search(r"using std::f?abs;", contents):
  63       using_std_abs_files.append(f.LocalPath())
  64     if re.search(r"\bfabsf?\(", contents):
  65       found_fabs_files.append(f.LocalPath());
  66
  67     no_std_prefix = r"(?<!std::)"
  68     # Matches occurrences of abs/absf/fabs/fabsf without a "std::" prefix.
  69     abs_without_prefix = r"%s(\babsf?\()" % no_std_prefix
  70     fabs_without_prefix = r"%s(\bfabsf?\()" % no_std_prefix
  71     # Skips matching any lines that have "// NOLINT".
  72     no_nolint = r"(?![^\n]*//\s+NOLINT)"
  73
  74     expression = re.compile("(%s|%s)%s" %
  75         (abs_without_prefix, fabs_without_prefix, no_nolint))
  76     if expression.search(contents):
  77       missing_std_prefix_files.append(f.LocalPath())
  78
  79   result = []
  80   if using_std_abs_files:
  81     result.append(output_api.PresubmitError(
  82         'These files have "using std::abs" which is not permitted.',
  83         items=using_std_abs_files))
  84   if found_fabs_files:
  85     result.append(output_api.PresubmitError(
  86         'std::abs() should be used instead of std::fabs() for consistency.',
  87         items=found_fabs_files))
  88   if missing_std_prefix_files:
  89     result.append(output_api.PresubmitError(
  90         'These files use abs(), absf(), fabs(), or fabsf() without qualifying '
  91         'the std namespace. Please use std::abs() in all places.',
  92         items=missing_std_prefix_files))
  93   return result
  94
  95 def CheckPassByValue(input_api,
  96                      output_api,
  97                      white_list=CC_SOURCE_FILES,
  98                      black_list=None):
  99   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
 100   source_file_filter = lambda x: input_api.FilterSourceFile(x,
 101                                                             white_list,
 102                                                             black_list)
 103
 104   local_errors = []
 105
 106   # Well-defined simple classes containing only <= 4 ints, or <= 2 floats.
 107   pass_by_value_types = ['base::Time',
 108                          'base::TimeTicks',
 109                          ]
 110
 111   for f in input_api.AffectedSourceFiles(source_file_filter):
 112     contents = input_api.ReadFile(f, 'rb')
 113     match = re.search(
 114       r'\bconst +' + '(?P<type>(%s))&' %
 115         string.join(pass_by_value_types, '|'),
 116       contents)
 117     if match:
 118       local_errors.append(output_api.PresubmitError(
 119         '%s passes %s by const ref instead of by value.' %
 120         (f.LocalPath(), match.group('type'))))
 121   return local_errors
 122
 123 def CheckTodos(input_api, output_api):
 124   errors = []
 125
 126   source_file_filter = lambda x: x
 127   for f in input_api.AffectedSourceFiles(source_file_filter):
 128     contents = input_api.ReadFile(f, 'rb')
 129     if ('FIX'+'ME') in contents:
 130       errors.append(f.LocalPath())
 131
 132   if errors:
 133     return [output_api.PresubmitError(
 134       'All TODO comments should be of the form TODO(name). ' +
 135       'Use TODO instead of FIX' + 'ME',
 136       items=errors)]
 137   return []
 138
 139 def CheckDoubleAngles(input_api, output_api, white_list=CC_SOURCE_FILES,
 140                       black_list=None):
 141   errors = []
 142
 143   source_file_filter = lambda x: input_api.FilterSourceFile(x,
 144                                                             white_list,
 145                                                             black_list)
 146   for f in input_api.AffectedSourceFiles(source_file_filter):
 147     contents = input_api.ReadFile(f, 'rb')
 148     if ('> >') in contents:
 149       errors.append(f.LocalPath())
 150
 151   if errors:
 152     return [output_api.PresubmitError('Use >> instead of > >:', items=errors)]
 153   return []
 154
 155 def CheckScopedPtr(input_api, output_api,
 156                    white_list=CC_SOURCE_FILES, black_list=None):
 157   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
 158   source_file_filter = lambda x: input_api.FilterSourceFile(x,
 159                                                             white_list,
 160                                                             black_list)
 161   errors = []
 162   for f in input_api.AffectedSourceFiles(source_file_filter):
 163     for line_number, line in f.ChangedContents():
 164       # Disallow:
 165       # return scoped_ptr<T>(foo);
 166       # bar = scoped_ptr<T>(foo);
 167       # But allow:
 168       # return scoped_ptr<T[]>(foo);
 169       # bar = scoped_ptr<T[]>(foo);
 170       if re.search(r'(=|\breturn)\s*scoped_ptr<.*?(?<!])>\([^)]+\)', line):
 171         errors.append(output_api.PresubmitError(
 172           ('%s:%d uses explicit scoped_ptr constructor. ' +
 173            'Use make_scoped_ptr() instead.') % (f.LocalPath(), line_number)))
 174       # Disallow:
 175       # scoped_ptr<T>()
 176       if re.search(r'\bscoped_ptr<.*?>\(\)', line):
 177         errors.append(output_api.PresubmitError(
 178           '%s:%d uses scoped_ptr<T>(). Use nullptr instead.' %
 179           (f.LocalPath(), line_number)))
 180   return errors
 181
 182 def FindUnquotedQuote(contents, pos):
 183   match = re.search(r"(?<!\\)(?P<quote>\")", contents[pos:])
 184   return -1 if not match else match.start("quote") + pos
 185
 186 def FindUselessIfdefs(input_api, output_api):
 187   errors = []
 188   source_file_filter = lambda x: x
 189   for f in input_api.AffectedSourceFiles(source_file_filter):
 190     contents = input_api.ReadFile(f, 'rb')
 191     if re.search(r'#if\s*0\s', contents):
 192       errors.append(f.LocalPath())
 193   if errors:
 194     return [output_api.PresubmitError(
 195       'Don\'t use #if '+'0; just delete the code.',
 196       items=errors)]
 197   return []
 198
 199 def FindNamespaceInBlock(pos, namespace, contents, whitelist=[]):
 200   open_brace = -1
 201   close_brace = -1
 202   quote = -1
 203   name = -1
 204   brace_count = 1
 205   quote_count = 0
 206   while pos < len(contents) and brace_count > 0:
 207     if open_brace < pos: open_brace = contents.find("{", pos)
 208     if close_brace < pos: close_brace = contents.find("}", pos)
 209     if quote < pos: quote = FindUnquotedQuote(contents, pos)
 210     if name < pos: name = contents.find(("%s::" % namespace), pos)
 211
 212     if name < 0:
 213       return False # The namespace is not used at all.
 214     if open_brace < 0:
 215       open_brace = len(contents)
 216     if close_brace < 0:
 217       close_brace = len(contents)
 218     if quote < 0:
 219       quote = len(contents)
 220
 221     next = min(open_brace, min(close_brace, min(quote, name)))
 222
 223     if next == open_brace:
 224       brace_count += 1
 225     elif next == close_brace:
 226       brace_count -= 1
 227     elif next == quote:
 228       quote_count = 0 if quote_count else 1
 229     elif next == name and not quote_count:
 230       in_whitelist = False
 231       for w in whitelist:
 232         if re.match(w, contents[next:]):
 233           in_whitelist = True
 234           break
 235       if not in_whitelist:
 236         return True
 237     pos = next + 1
 238   return False
 239
 240 # Checks for the use of cc:: within the cc namespace, which is usually
 241 # redundant.
 242 def CheckNamespace(input_api, output_api):
 243   errors = []
 244
 245   source_file_filter = lambda x: x
 246   for f in input_api.AffectedSourceFiles(source_file_filter):
 247     contents = input_api.ReadFile(f, 'rb')
 248     match = re.search(r'namespace\s*cc\s*{', contents)
 249     if match:
 250       whitelist = [
 251         r"cc::remove_if\b",
 252         ]
 253       if FindNamespaceInBlock(match.end(), 'cc', contents, whitelist=whitelist):
 254         errors.append(f.LocalPath())
 255
 256   if errors:
 257     return [output_api.PresubmitError(
 258       'Do not use cc:: inside of the cc namespace.',
 259       items=errors)]
 260   return []
 261
 262 def CheckForUseOfWrongClock(input_api,
 263                             output_api,
 264                             white_list=CC_SOURCE_FILES,
 265                             black_list=None):
 266   """Make sure new lines of code don't use a clock susceptible to skew."""
 267   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
 268   source_file_filter = lambda x: input_api.FilterSourceFile(x,
 269                                                             white_list,
 270                                                             black_list)
 271   # Regular expression that should detect any explicit references to the
 272   # base::Time type (or base::Clock/DefaultClock), whether in using decls,
 273   # typedefs, or to call static methods.
 274   base_time_type_pattern = r'(^|\W)base::(Time|Clock|DefaultClock)(\W|$)'
 275
 276   # Regular expression that should detect references to the base::Time class
 277   # members, such as a call to base::Time::Now.
 278   base_time_member_pattern = r'(^|\W)(Time|Clock|DefaultClock)::'
 279
 280   # Regular expression to detect "using base::Time" declarations.  We want to
 281   # prevent these from triggerring a warning.  For example, it's perfectly
 282   # reasonable for code to be written like this:
 283   #
 284   #   using base::Time;
 285   #   ...
 286   #   int64 foo_us = foo_s * Time::kMicrosecondsPerSecond;
 287   using_base_time_decl_pattern = r'^\s*using\s+(::)?base::Time\s*;'
 288
 289   # Regular expression to detect references to the kXXX constants in the
 290   # base::Time class.  We want to prevent these from triggerring a warning.
 291   base_time_konstant_pattern = r'(^|\W)Time::k\w+'
 292
 293   problem_re = input_api.re.compile(
 294       r'(' + base_time_type_pattern + r')|(' + base_time_member_pattern + r')')
 295   exception_re = input_api.re.compile(
 296       r'(' + using_base_time_decl_pattern + r')|(' +
 297       base_time_konstant_pattern + r')')
 298   problems = []
 299   for f in input_api.AffectedSourceFiles(source_file_filter):
 300     for line_number, line in f.ChangedContents():
 301       if problem_re.search(line):
 302         if not exception_re.search(line):
 303           problems.append(
 304               '  %s:%d\n    %s' % (f.LocalPath(), line_number, line.strip()))
 305
 306   if problems:
 307     return [output_api.PresubmitPromptOrNotify(
 308         'You added one or more references to the base::Time class and/or one\n'
 309         'of its member functions (or base::Clock/DefaultClock). In cc code,\n'
 310         'it is most certainly incorrect! Instead use base::TimeTicks.\n\n'
 311         '\n'.join(problems))]
 312   else:
 313     return []
 314
 315 def CheckChangeOnUpload(input_api, output_api):
 316   results = []
 317   results += CheckAsserts(input_api, output_api)
 318   results += CheckStdAbs(input_api, output_api)
 319   results += CheckPassByValue(input_api, output_api)
 320   results += CheckChangeLintsClean(input_api, output_api)
 321   results += CheckTodos(input_api, output_api)
 322   results += CheckDoubleAngles(input_api, output_api)
 323   results += CheckScopedPtr(input_api, output_api)
 324   results += CheckNamespace(input_api, output_api)
 325   results += CheckForUseOfWrongClock(input_api, output_api)
 326   results += FindUselessIfdefs(input_api, output_api)
 327   results += input_api.canned_checks.CheckPatchFormatted(input_api, output_api)
 328   return results
 329
 330 def GetPreferredTryMasters(project, change):
 331   return {
 332     'tryserver.blink': {
 333       'linux_blink_rel': set(['defaulttests']),
 334     },
 335   }