Googletest export

googlemock/scripts/generator/cpp/ast.py

@@ -610,9 +610,21 @@ class TypeConverter(object):
       result.append(p)
 
     template_count = 0
+    brace_count = 0
     for s in tokens:
       if not first_token:
         first_token = s
+
+      # Check for braces before templates, as we can have unmatched '<>'
+      # inside default arguments.
+      if s.name == '{':
+        brace_count += 1
+      elif s.name == '}':
+        brace_count -= 1
+      if brace_count > 0:
+        type_modifiers.append(s)
+        continue
+
       if s.name == '<':
         template_count += 1
       elif s.name == '>':

googlemock/scripts/generator/cpp/gmock_class.py

@@ -53,10 +53,8 @@ def _RenderType(ast_type):
     ast_type: The AST of the type.
 
   Returns:
-    Rendered string and a boolean to indicate whether we have multiple args
-    (which is not handled correctly).
+    Rendered string of the type.
   """
-    has_multiarg_error = False
   # Add modifiers like 'const'.
   modifiers = ''
   if ast_type.modifiers:
@@ -66,82 +64,81 @@ def _RenderType(ast_type):
     # Collect template args.
     template_args = []
     for arg in ast_type.templated_types:
-            rendered_arg, e = _RenderType(arg)
-            if e: has_multiarg_error = True
+      rendered_arg = _RenderType(arg)
       template_args.append(rendered_arg)
     return_type += '<' + ', '.join(template_args) + '>'
-        # We are actually not handling multi-template-args correctly. So mark it.
-        if len(template_args) > 1:
-            has_multiarg_error = True
   if ast_type.pointer:
     return_type += '*'
   if ast_type.reference:
     return_type += '&'
-    return return_type, has_multiarg_error
+  return return_type
 
 
-def _GetNumParameters(parameters, source):
-    num_parameters = len(parameters)
-    if num_parameters == 1:
-        first_param = parameters[0]
-        if source[first_param.start:first_param.end].strip() == 'void':
-            # We must treat T(void) as a function with no parameters.
-            return 0
-    return num_parameters
+def _GenerateArg(source):
+  """Strips out comments, default arguments, and redundant spaces from a single argument.
+
+  Args:
+    source: A string for a single argument.
+
+  Returns:
+    Rendered string of the argument.
+  """
+  # Remove end of line comments before eliminating newlines.
+  arg = re.sub(r'//.*', '', source)
+
+  # Remove c-style comments.
+  arg = re.sub(r'/\*.*\*/', '', arg)
+
+  # Remove default arguments.
+  arg = re.sub(r'=.*', '', arg)
+
+  # Collapse spaces and newlines into a single space.
+  arg = re.sub(r'\s+', ' ', arg)
+  return arg.strip()
+
+
+def _EscapeForMacro(s):
+  """Escapes a string for use as an argument to a C++ macro."""
+  paren_count = 0
+  for c in s:
+    if c == '(':
+      paren_count += 1
+    elif c == ')':
+      paren_count -= 1
+    elif c == ',' and paren_count == 0:
+      return '(' + s + ')'
+  return s
 
 
 def _GenerateMethods(output_lines, source, class_node):
-    function_type = (ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL |
-                     ast.FUNCTION_OVERRIDE)
+  function_type = (
+      ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL | ast.FUNCTION_OVERRIDE)
   ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR
   indent = ' ' * _INDENT
 
   for node in class_node.body:
     # We only care about virtual functions.
-        if (isinstance(node, ast.Function) and
-                node.modifiers & function_type and
+    if (isinstance(node, ast.Function) and node.modifiers & function_type and
         not node.modifiers & ctor_or_dtor):
       # Pick out all the elements we need from the original function.
-            const = ''
+      modifiers = 'override'
       if node.modifiers & ast.FUNCTION_CONST:
-                const = 'CONST_'
-            num_parameters = _GetNumParameters(node.parameters, source)
+        modifiers = 'const, ' + modifiers
+
       return_type = 'void'
       if node.return_type:
-                return_type, has_multiarg_error = _RenderType(node.return_type)
-                if has_multiarg_error:
-                    for line in [
-                        '// The following line won\'t really compile, as the return',
-                        '// type has multiple template arguments.  To fix it, use a',
-                        '// typedef for the return type.']:
-                        output_lines.append(indent + line)
-            tmpl = ''
-            if class_node.templated_types:
-                tmpl = '_T'
-            mock_method_macro = 'MOCK_%sMETHOD%d%s' % (const, num_parameters, tmpl)
-
-            args = ''
-            if node.parameters:
-                # Get the full text of the parameters from the start
-                # of the first parameter to the end of the last parameter.
-                start = node.parameters[0].start
-                end = node.parameters[-1].end
-                # Remove // comments.
-                args_strings = re.sub(r'//.*', '', source[start:end])
-                # Remove /* comments */.
-                args_strings = re.sub(r'/\*.*\*/', '', args_strings)
-                # Remove default arguments.
-                args_strings = re.sub(r'=.*,', ',', args_strings)
-                args_strings = re.sub(r'=.*', '', args_strings)
-                # Condense multiple spaces and eliminate newlines putting the
-                # parameters together on a single line.  Ensure there is a
-                # space in an argument which is split by a newline without
-                # intervening whitespace, e.g.: int\nBar
-                args = re.sub('  +', ' ', args_strings.replace('\n', ' '))
+        return_type = _EscapeForMacro(_RenderType(node.return_type))
+
+      args = []
+      for p in node.parameters:
+        arg = _GenerateArg(source[p.start:p.end])
+        args.append(_EscapeForMacro(arg))
 
       # Create the mock method definition.
-            output_lines.extend(['%s%s(%s,' % (indent, mock_method_macro, node.name),
-                                 '%s%s(%s));' % (indent * 3, return_type, args)])
+      output_lines.extend([
+          '%sMOCK_METHOD(%s, %s, (%s), (%s));' %
+          (indent, return_type, node.name, ', '.join(args), modifiers)
+      ])
 
 
 def _GenerateMocks(filename, source, ast_list, desired_class_names):