gmock_doctor.py 22.4 KB
Newer Older
1
#!/usr/bin/env python
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#
# Copyright 2008, Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
#     * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

32
"""Converts compiler's errors in code using Google Mock to plain English."""
33
34
35
36
37
38

__author__ = 'wan@google.com (Zhanyong Wan)'

import re
import sys

39
_VERSION = '1.0.3'
40

41
42
_EMAIL = 'googlemock@googlegroups.com'

43
44
45
46
47
48
49
50
_COMMON_GMOCK_SYMBOLS = [
    # Matchers
    '_',
    'A',
    'AddressSatisfies',
    'AllOf',
    'An',
    'AnyOf',
51
52
    'ContainerEq',
    'Contains',
53
54
    'ContainsRegex',
    'DoubleEq',
55
56
    'ElementsAre',
    'ElementsAreArray',
57
58
59
60
61
62
63
    'EndsWith',
    'Eq',
    'Field',
    'FloatEq',
    'Ge',
    'Gt',
    'HasSubstr',
64
    'IsInitializedProto',
65
66
67
    'Le',
    'Lt',
    'MatcherCast',
68
    'Matches',
69
    'MatchesRegex',
70
71
    'NanSensitiveDoubleEq',
    'NanSensitiveFloatEq',
72
73
74
75
76
77
    'Ne',
    'Not',
    'NotNull',
    'Pointee',
    'Property',
    'Ref',
78
79
    'ResultOf',
    'SafeMatcherCast',
80
81
82
83
84
85
86
    'StartsWith',
    'StrCaseEq',
    'StrCaseNe',
    'StrEq',
    'StrNe',
    'Truly',
    'TypedEq',
87
    'Value',
88
89

    # Actions
90
    'Assign',
91
    'ByRef',
92
    'DeleteArg',
93
94
95
96
97
98
99
    'DoAll',
    'DoDefault',
    'IgnoreResult',
    'Invoke',
    'InvokeArgument',
    'InvokeWithoutArgs',
    'Return',
100
    'ReturnNew',
101
102
    'ReturnNull',
    'ReturnRef',
103
104
    'SaveArg',
    'SetArgReferee',
105
    'SetArgPointee',
106
107
    'SetArgumentPointee',
    'SetArrayArgument',
108
109
110
    'SetErrnoAndReturn',
    'Throw',
    'WithArg',
111
    'WithArgs',
112
    'WithoutArgs',
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

    # Cardinalities
    'AnyNumber',
    'AtLeast',
    'AtMost',
    'Between',
    'Exactly',

    # Sequences
    'InSequence',
    'Sequence',

    # Misc
    'DefaultValue',
    'Mock',
    ]

130
131
132
133
134
# Regex for matching source file path and line number in the compiler's errors.
_GCC_FILE_LINE_RE = r'(?P<file>.*):(?P<line>\d+):\s+'
_CLANG_FILE_LINE_RE = r'(?P<file>.*):(?P<line>\d+):(?P<column>\d+):\s+'
_CLANG_NON_GMOCK_FILE_LINE_RE = (
    r'(?P<file>.*[/\\^](?!gmock-)[^/\\]+):(?P<line>\d+):(?P<column>\d+):\s+')
135

136
137
138
139
140
141
142
143

def _FindAllMatches(regex, s):
  """Generates all matches of regex in string s."""

  r = re.compile(regex)
  return r.finditer(s)


144
def _GenericDiagnoser(short_name, long_name, diagnoses, msg):
145
146
  """Diagnoses the given disease by pattern matching.

147
148
  Can provide different diagnoses for different patterns.

149
150
151
  Args:
    short_name: Short name of the disease.
    long_name:  Long name of the disease.
152
153
154
    diagnoses:  A list of pairs (regex, pattern for formatting the diagnosis
                for matching regex).
    msg:        Compiler's error messages.
155
156
157
158
  Yields:
    Tuples of the form
      (short name of disease, long name of disease, diagnosis).
  """
159
160
161
162
163
  for regex, diagnosis in diagnoses:
    if re.search(regex, msg):
      diagnosis = '%(file)s:%(line)s:' + diagnosis
      for m in _FindAllMatches(regex, msg):
        yield (short_name, long_name, diagnosis % m.groupdict())
164
165
166


def _NeedToReturnReferenceDiagnoser(msg):
167
168
169
170
171
  """Diagnoses the NRR disease, given the error messages by the compiler."""

  gcc_regex = (r'In member function \'testing::internal::ReturnAction<R>.*\n'
               + _GCC_FILE_LINE_RE + r'instantiated from here\n'
               r'.*gmock-actions\.h.*error: creating array with negative size')
172
  clang_regex = (r'error:.*array.*negative.*\r?\n'
173
174
175
                 r'(.*\n)*?' +
                 _CLANG_NON_GMOCK_FILE_LINE_RE +
                 r'note: in instantiation of function template specialization '
176
                 r'\'testing::internal::ReturnAction<(?P<type>.*)>'
177
                 r'::operator Action<.*>\' requested here')
178
  diagnosis = """
179
180
You are using a Return() action in a function that returns a reference to
%(type)s.  Please use ReturnRef() instead."""
181
  return _GenericDiagnoser('NRR', 'Need to Return Reference',
182
183
184
                           [(clang_regex, diagnosis),
                            (gcc_regex, diagnosis % {'type': 'a type'})],
                           msg)
185
186
187


def _NeedToReturnSomethingDiagnoser(msg):
188
189
190
191
192
193
194
  """Diagnoses the NRS disease, given the error messages by the compiler."""

  gcc_regex = (_GCC_FILE_LINE_RE + r'(instantiated from here\n.'
               r'*gmock.*actions\.h.*error: void value not ignored)'
               r'|(error: control reaches end of non-void function)')
  clang_regex1 = (_CLANG_FILE_LINE_RE +
                  r'error: cannot initialize return object '
195
                  r'of type \'Result\' \(aka \'(?P<return_type>.*)\'\) '
196
197
198
                  r'with an rvalue of type \'void\'')
  clang_regex2 = (_CLANG_FILE_LINE_RE +
                  r'error: cannot initialize return object '
199
                  r'of type \'(?P<return_type>.*)\' '
200
                  r'with an rvalue of type \'void\'')
201
  diagnosis = """
202
You are using an action that returns void, but it needs to return
203
%(return_type)s.  Please tell it *what* to return.  Perhaps you can use
204
the pattern DoAll(some_action, Return(some_value))?"""
205
206
207
208
209
210
211
  return _GenericDiagnoser(
      'NRS',
      'Need to Return Something',
      [(gcc_regex, diagnosis % {'return_type': '*something*'}),
       (clang_regex1, diagnosis),
       (clang_regex2, diagnosis)],
      msg)
212
213
214


def _NeedToReturnNothingDiagnoser(msg):
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
  """Diagnoses the NRN disease, given the error messages by the compiler."""

  gcc_regex = (_GCC_FILE_LINE_RE + r'instantiated from here\n'
               r'.*gmock-actions\.h.*error: instantiation of '
               r'\'testing::internal::ReturnAction<R>::Impl<F>::value_\' '
               r'as type \'void\'')
  clang_regex1 = (r'error: field has incomplete type '
                  r'\'Result\' \(aka \'void\'\)(\r)?\n'
                  r'(.*\n)*?' +
                  _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
                  r'of function template specialization '
                  r'\'testing::internal::ReturnAction<(?P<return_type>.*)>'
                  r'::operator Action<void \(.*\)>\' requested here')
  clang_regex2 = (r'error: field has incomplete type '
                  r'\'Result\' \(aka \'void\'\)(\r)?\n'
                  r'(.*\n)*?' +
                  _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
                  r'of function template specialization '
                  r'\'testing::internal::DoBothAction<.*>'
                  r'::operator Action<(?P<return_type>.*) \(.*\)>\' '
                  r'requested here')
236
  diagnosis = """
237
You are using an action that returns %(return_type)s, but it needs to return
238
239
240
241
void.  Please use a void-returning action instead.

All actions but the last in DoAll(...) must return void.  Perhaps you need
to re-arrange the order of actions in a DoAll(), if you are using one?"""
242
243
244
245
246
247
248
  return _GenericDiagnoser(
      'NRN',
      'Need to Return Nothing',
      [(gcc_regex, diagnosis % {'return_type': '*something*'}),
       (clang_regex1, diagnosis),
       (clang_regex2, diagnosis)],
      msg)
249
250
251


def _IncompleteByReferenceArgumentDiagnoser(msg):
252
253
254
255
256
257
258
259
260
261
262
263
  """Diagnoses the IBRA disease, given the error messages by the compiler."""

  gcc_regex = (_GCC_FILE_LINE_RE + r'instantiated from here\n'
               r'.*gtest-printers\.h.*error: invalid application of '
               r'\'sizeof\' to incomplete type \'(?P<type>.*)\'')

  clang_regex = (r'.*gtest-printers\.h.*error: invalid application of '
                 r'\'sizeof\' to an incomplete type '
                 r'\'(?P<type>.*)( const)?\'\r?\n'
                 r'(.*\n)*?' +
                 _CLANG_NON_GMOCK_FILE_LINE_RE +
                 r'note: in instantiation of member function '
264
265
                 r'\'testing::internal2::TypeWithoutFormatter<.*>::'
                 r'PrintValue\' requested here')
266
  diagnosis = """
267
268
269
270
In order to mock this function, Google Mock needs to see the definition
of type "%(type)s" - declaration alone is not enough.  Either #include
the header that defines it, or change the argument to be passed
by pointer."""
271

272
  return _GenericDiagnoser('IBRA', 'Incomplete By-Reference Argument Type',
273
274
275
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
276
277
278


def _OverloadedFunctionMatcherDiagnoser(msg):
279
  """Diagnoses the OFM disease, given the error messages by the compiler."""
280

281
282
283
284
  gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for '
               r'call to \'Truly\(<unresolved overloaded function type>\)')
  clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching function for '
                 r'call to \'Truly')
285
  diagnosis = """
286
The argument you gave to Truly() is an overloaded function.  Please tell
287
your compiler which overloaded version you want to use.
288
289
290
291
292
293

For example, if you want to use the version whose signature is
  bool Foo(int n);
you should write
  Truly(static_cast<bool (*)(int n)>(Foo))"""
  return _GenericDiagnoser('OFM', 'Overloaded Function Matcher',
294
295
296
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
297
298
299


def _OverloadedFunctionActionDiagnoser(msg):
300
301
302
303
304
305
306
307
308
309
  """Diagnoses the OFA disease, given the error messages by the compiler."""

  gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for call to '
               r'\'Invoke\(<unresolved overloaded function type>')
  clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching '
                 r'function for call to \'Invoke\'\r?\n'
                 r'(.*\n)*?'
                 r'.*\bgmock-\w+-actions\.h:\d+:\d+:\s+'
                 r'note: candidate template ignored:\s+'
                 r'couldn\'t infer template argument \'FunctionImpl\'')
310
  diagnosis = """
311
Function you are passing to Invoke is overloaded.  Please tell your compiler
312
313
314
315
316
317
318
which overloaded version you want to use.

For example, if you want to use the version whose signature is
  bool MyFunction(int n, double x);
you should write something like
  Invoke(static_cast<bool (*)(int n, double x)>(MyFunction))"""
  return _GenericDiagnoser('OFA', 'Overloaded Function Action',
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)


def _OverloadedMethodActionDiagnoser(msg):
  """Diagnoses the OMA disease, given the error messages by the compiler."""

  gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for '
               r'call to \'Invoke\(.+, <unresolved overloaded function '
               r'type>\)')
  clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching function '
                 r'for call to \'Invoke\'\r?\n'
                 r'(.*\n)*?'
                 r'.*\bgmock-\w+-actions\.h:\d+:\d+: '
                 r'note: candidate function template not viable: '
                 r'requires 1 argument, but 2 were provided')
336
  diagnosis = """
337
The second argument you gave to Invoke() is an overloaded method.  Please
338
tell your compiler which overloaded version you want to use.
339
340
341
342
343
344
345
346
347

For example, if you want to use the version whose signature is
  class Foo {
    ...
    bool Bar(int n, double x);
  };
you should write something like
  Invoke(foo, static_cast<bool (Foo::*)(int n, double x)>(&Foo::Bar))"""
  return _GenericDiagnoser('OMA', 'Overloaded Method Action',
348
349
350
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
351
352
353


def _MockObjectPointerDiagnoser(msg):
354
355
356
357
358
359
360
361
  """Diagnoses the MOP disease, given the error messages by the compiler."""

  gcc_regex = (_GCC_FILE_LINE_RE + r'error: request for member '
               r'\'gmock_(?P<method>.+)\' in \'(?P<mock_object>.+)\', '
               r'which is of non-class type \'(.*::)*(?P<class_name>.+)\*\'')
  clang_regex = (_CLANG_FILE_LINE_RE + r'error: member reference type '
                 r'\'(?P<class_name>.*?) *\' is a pointer; '
                 r'maybe you meant to use \'->\'\?')
362
  diagnosis = """
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
The first argument to ON_CALL() and EXPECT_CALL() must be a mock *object*,
not a *pointer* to it.  Please write '*(%(mock_object)s)' instead of
'%(mock_object)s' as your first argument.

For example, given the mock class:

  class %(class_name)s : public ... {
    ...
    MOCK_METHOD0(%(method)s, ...);
  };

and the following mock instance:

  %(class_name)s* mock_ptr = ...

you should use the EXPECT_CALL like this:

  EXPECT_CALL(*mock_ptr, %(method)s(...));"""

382
383
384
385
386
387
388
389
  return _GenericDiagnoser(
      'MOP',
      'Mock Object Pointer',
      [(gcc_regex, diagnosis),
       (clang_regex, diagnosis % {'mock_object': 'mock_object',
                                  'method': 'method',
                                  'class_name': '%(class_name)s'})],
       msg)
390
391
392


def _NeedToUseSymbolDiagnoser(msg):
393
  """Diagnoses the NUS disease, given the error messages by the compiler."""
394

395
396
  gcc_regex = (_GCC_FILE_LINE_RE + r'error: \'(?P<symbol>.+)\' '
               r'(was not declared in this scope|has not been declared)')
397
  clang_regex = (_CLANG_FILE_LINE_RE +
398
399
                 r'error: (use of undeclared identifier|unknown type name|'
                 r'no template named) \'(?P<symbol>[^\']+)\'')
400
  diagnosis = """
401
402
403
404
'%(symbol)s' is defined by Google Mock in the testing namespace.
Did you forget to write
  using testing::%(symbol)s;
?"""
405
406
  for m in (list(_FindAllMatches(gcc_regex, msg)) +
            list(_FindAllMatches(clang_regex, msg))):
407
408
409
410
411
    symbol = m.groupdict()['symbol']
    if symbol in _COMMON_GMOCK_SYMBOLS:
      yield ('NUS', 'Need to Use Symbol', diagnosis % m.groupdict())


412
def _NeedToUseReturnNullDiagnoser(msg):
413
414
415
416
417
  """Diagnoses the NRNULL disease, given the error messages by the compiler."""

  gcc_regex = ('instantiated from \'testing::internal::ReturnAction<R>'
               '::operator testing::Action<Func>\(\) const.*\n' +
               _GCC_FILE_LINE_RE + r'instantiated from here\n'
418
               r'.*error: no matching function for call to \'ImplicitCast_\('
419
420
               r'long int&\)')
  clang_regex = (r'\bgmock-actions.h:.* error: no matching function for '
421
                 r'call to \'ImplicitCast_\'\r?\n'
422
423
424
425
426
                 r'(.*\n)*?' +
                 _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
                 r'of function template specialization '
                 r'\'testing::internal::ReturnAction<long>::operator '
                 r'Action<(?P<type>.*)\(\)>\' requested here')
427
  diagnosis = """
428
You are probably calling Return(NULL) and the compiler isn't sure how to turn
429
NULL into %(type)s. Use ReturnNull() instead.
430
Note: the line number may be off; please fix all instances of Return(NULL)."""
431
432
433
434
435
436
  return _GenericDiagnoser(
      'NRNULL', 'Need to use ReturnNull',
      [(clang_regex, diagnosis),
       (gcc_regex, diagnosis % {'type': 'the right type'})],
      msg)

437

438
439
def _TypeInTemplatedBaseDiagnoser(msg):
  """Diagnoses the TTB disease, given the error messages by the compiler."""
440

441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
  # This version works when the type is used as the mock function's return
  # type.
  gcc_4_3_1_regex_type_in_retval = (
      r'In member function \'int .*\n' + _GCC_FILE_LINE_RE +
      r'error: a function call cannot appear in a constant-expression')
  gcc_4_4_0_regex_type_in_retval = (
      r'error: a function call cannot appear in a constant-expression'
      + _GCC_FILE_LINE_RE + r'error: template argument 1 is invalid\n')
  # This version works when the type is used as the mock function's sole
  # parameter type.
  gcc_regex_type_of_sole_param = (
      _GCC_FILE_LINE_RE +
      r'error: \'(?P<type>.+)\' was not declared in this scope\n'
      r'.*error: template argument 1 is invalid\n')
  # This version works when the type is used as a parameter of a mock
  # function that has multiple parameters.
  gcc_regex_type_of_a_param = (
      r'error: expected `;\' before \'::\' token\n'
      + _GCC_FILE_LINE_RE +
      r'error: \'(?P<type>.+)\' was not declared in this scope\n'
      r'.*error: template argument 1 is invalid\n'
      r'.*error: \'.+\' was not declared in this scope')
463
464
465
466
  clang_regex_type_of_retval_or_sole_param = (
      _CLANG_FILE_LINE_RE +
      r'error: use of undeclared identifier \'(?P<type>.*)\'\n'
      r'(.*\n)*?'
467
      r'(?P=file):(?P=line):\d+: error: '
468
469
470
471
472
473
474
475
476
      r'non-friend class member \'Result\' cannot have a qualified name'
      )
  clang_regex_type_of_a_param = (
      _CLANG_FILE_LINE_RE +
      r'error: C\+\+ requires a type specifier for all declarations\n'
      r'(.*\n)*?'
      r'(?P=file):(?P=line):(?P=column): error: '
      r'C\+\+ requires a type specifier for all declarations'
      )
477
478

  diagnosis = """
479
480
481
482
483
484
485
In a mock class template, types or typedefs defined in the base class
template are *not* automatically visible.  This is how C++ works.  Before
you can use a type or typedef named %(type)s defined in base class Base<T>, you
need to make it visible.  One way to do it is:

  typedef typename Base<T>::%(type)s %(type)s;"""

486
487
488
489
490
  return _GenericDiagnoser(
      'TTB', 'Type in Template Base',
      [(gcc_4_3_1_regex_type_in_retval, diagnosis % {'type': 'Foo'}),
       (gcc_4_4_0_regex_type_in_retval, diagnosis % {'type': 'Foo'}),
       (gcc_regex_type_of_sole_param, diagnosis),
491
492
493
       (gcc_regex_type_of_a_param, diagnosis),
       (clang_regex_type_of_retval_or_sole_param, diagnosis),
       (clang_regex_type_of_a_param, diagnosis % {'type': 'Foo'})],
494
      msg)
495
496


497
def _WrongMockMethodMacroDiagnoser(msg):
498
499
500
501
502
503
504
  """Diagnoses the WMM disease, given the error messages by the compiler."""

  gcc_regex = (_GCC_FILE_LINE_RE +
               r'.*this_method_does_not_take_(?P<wrong_args>\d+)_argument.*\n'
               r'.*\n'
               r'.*candidates are.*FunctionMocker<[^>]+A(?P<args>\d+)\)>')
  clang_regex = (_CLANG_NON_GMOCK_FILE_LINE_RE +
505
                 r'error:.*array.*negative.*r?\n'
506
507
508
509
                 r'(.*\n)*?'
                 r'(?P=file):(?P=line):(?P=column): error: too few arguments '
                 r'to function call, expected (?P<args>\d+), '
                 r'have (?P<wrong_args>\d+)')
510
  diagnosis = """
511
512
513
You are using MOCK_METHOD%(wrong_args)s to define a mock method that has
%(args)s arguments. Use MOCK_METHOD%(args)s (or MOCK_CONST_METHOD%(args)s,
MOCK_METHOD%(args)s_T, MOCK_CONST_METHOD%(args)s_T as appropriate) instead."""
514
  return _GenericDiagnoser('WMM', 'Wrong MOCK_METHODn Macro',
515
516
517
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
518
519


520
def _WrongParenPositionDiagnoser(msg):
521
522
523
524
525
526
527
528
  """Diagnoses the WPP disease, given the error messages by the compiler."""

  gcc_regex = (_GCC_FILE_LINE_RE +
               r'error:.*testing::internal::MockSpec<.* has no member named \''
               r'(?P<method>\w+)\'')
  clang_regex = (_CLANG_NON_GMOCK_FILE_LINE_RE +
                 r'error: no member named \'(?P<method>\w+)\' in '
                 r'\'testing::internal::MockSpec<.*>\'')
529
530
531
532
533
534
  diagnosis = """
The closing parenthesis of ON_CALL or EXPECT_CALL should be *before*
".%(method)s".  For example, you should write:
  EXPECT_CALL(my_mock, Foo(_)).%(method)s(...);
instead of:
  EXPECT_CALL(my_mock, Foo(_).%(method)s(...));"""
535
  return _GenericDiagnoser('WPP', 'Wrong Parenthesis Position',
536
537
538
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
539

540

541
542
543
544
545
546
_DIAGNOSERS = [
    _IncompleteByReferenceArgumentDiagnoser,
    _MockObjectPointerDiagnoser,
    _NeedToReturnNothingDiagnoser,
    _NeedToReturnReferenceDiagnoser,
    _NeedToReturnSomethingDiagnoser,
547
    _NeedToUseReturnNullDiagnoser,
548
549
550
    _NeedToUseSymbolDiagnoser,
    _OverloadedFunctionActionDiagnoser,
    _OverloadedFunctionMatcherDiagnoser,
551
552
    _OverloadedMethodActionDiagnoser,
    _TypeInTemplatedBaseDiagnoser,
553
    _WrongMockMethodMacroDiagnoser,
554
    _WrongParenPositionDiagnoser,
555
556
557
558
    ]


def Diagnose(msg):
559
560
561
  """Generates all possible diagnoses given the compiler error message."""

  msg = re.sub(r'\x1b\[[^m]*m', '', msg)  # Strips all color formatting.
562

563
  diagnoses = []
564
  for diagnoser in _DIAGNOSERS:
565
566
567
568
569
    for diag in diagnoser(msg):
      diagnosis = '[%s - %s]\n%s' % diag
      if not diagnosis in diagnoses:
        diagnoses.append(diagnosis)
  return diagnoses
570
571
572
573
574
575
576
577
578
579
580
581
582


def main():
  print ('Google Mock Doctor v%s - '
         'diagnoses problems in code using Google Mock.' % _VERSION)

  if sys.stdin.isatty():
    print ('Please copy and paste the compiler errors here.  Press c-D when '
           'you are done:')
  else:
    print 'Waiting for compiler errors on stdin . . .'

  msg = sys.stdin.read().strip()
583
  diagnoses = Diagnose(msg)
584
585
  count = len(diagnoses)
  if not count:
586
587
588
589
590
591
    print ("""
Your compiler complained:
8<------------------------------------------------------------
%s
------------------------------------------------------------>8

592
593
Uh-oh, I'm not smart enough to figure out what the problem is. :-(
However...
594
If you send your source code and the compiler's error messages to
595
596
%s, you can be helped and I can get smarter --
win-win for us!""" % (msg, _EMAIL))
597
598
599
600
601
602
603
604
605
606
607
608
609
  else:
    print '------------------------------------------------------------'
    print 'Your code appears to have the following',
    if count > 1:
      print '%s diseases:' % (count,)
    else:
      print 'disease:'
    i = 0
    for d in diagnoses:
      i += 1
      if count > 1:
        print '\n#%s:' % (i,)
      print d
610
    print ("""
611
How did I do?  If you think I'm wrong or unhelpful, please send your
612
613
614
source code and the compiler's error messages to %s.
Then you can be helped and I can get smarter -- I promise I won't be upset!""" %
           _EMAIL)
615
616
617
618


if __name__ == '__main__':
  main()