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