Avoid multiline warning strings in libcpychecker.formatstrings

When building with gcc 6, warnings emitted by
  libcpychecker.formatstrings.WrongNumberOfVars
showed some whitespace differences in the final " [-Werror]":

  ERROR: test_too_many_varargs (__main__.PyArg_ParseTupleAndKeywordsTests)
- [-Werror]
+    [-Werror]

I'm not sure exactly why this has started, but it seems error-prone to
be sending multiline strings through warning_at, so this patch standardizes
these warnings to emit just one line for the warning_at, and then print
the additional information to stderr via extra_info (), generalizing the
approach already used by MismatchingType.

Author: davidmalcolm

libcpychecker/formatstrings.py

@@ -1,5 +1,5 @@
-#   Copyright 2011 David Malcolm <[email protected]>
-#   Copyright 2011 Red Hat, Inc.
+#   Copyright 2011, 2016 David Malcolm <[email protected]>
+#   Copyright 2011, 2016 Red Hat, Inc.
 #
 #   This is free software: you can redistribute it and/or modify it
 #   under the terms of the GNU General Public License as published by
@@ -58,6 +58,13 @@ class FormatStringWarning(CExtensionWarning):
     def __init__(self, fmt_string):
         self.fmt_string = fmt_string
 
+    def emit_as_warning(self, loc):
+        if gcc.warning(loc, str(self)):
+            sys.stderr.write(self.extra_info())
+
+    def extra_info(self):
+        return ""
+
 class UnknownFormatChar(FormatStringWarning):
     def __init__(self, fmt_string, ch):
         FormatStringWarning.__init__(self, fmt_string)
@@ -137,12 +144,14 @@ def __init__(self, funcname, fmt, varargs):
         self.varargs = varargs
 
     def __str__(self):
-        result = ('%s in call to %s with format string "%s"\n'
-                  '  expected %i extra arguments:\n'
-                  % (self._get_desc_prefix(),
-                     self.funcname,
-                     self.fmt.fmt_string,
-                     self.fmt.num_expected()))
+        return ('%s in call to %s with format string "%s"'
+                % (self._get_desc_prefix(),
+                   self.funcname,
+                   self.fmt.fmt_string))
+
+    def extra_info(self):
+        result = ('  expected %i extra arguments:\n'
+                  % self.fmt.num_expected())
         for (arg, exp_type) in self.fmt.iter_exp_types():
             result += '    %s\n' % describe_type(exp_type)
         if len(self.varargs) == 0:
@@ -380,8 +389,8 @@ def check_callsite(stmt, parser, funcname, format_idx, varargs_idx, with_size_t)
                 try:
                     fmt = parser.from_string(fmt_string, with_size_t)
                 except FormatStringWarning:
-                    exc = sys.exc_info()[1]
-                    gcc.warning(stmt.loc, str(exc))
+                    err = sys.exc_info()[1]
+                    err.emit_as_warning(stmt.loc)
                     return
                 log('fmt: %r', fmt.args)
 
@@ -392,11 +401,11 @@ def check_callsite(stmt, parser, funcname, format_idx, varargs_idx, with_size_t)
                 varargs = stmt.args[varargs_idx:]
                 # log('varargs: %r', varargs)
                 if len(varargs) < len(exp_types):
-                    gcc.warning(loc, str(NotEnoughVars(funcname, fmt, varargs)))
+                    NotEnoughVars(funcname, fmt, varargs).emit_as_warning(loc)
                     return
 
                 if len(varargs) > len(exp_types):
-                    gcc.warning(loc, str(TooManyVars(funcname, fmt, varargs)))
+                    TooManyVars(funcname, fmt, varargs).emit_as_warning(loc)
                     return
 
                 for index, ((exp_arg, exp_type), vararg) in enumerate(zip(exp_types, varargs)):
@@ -408,9 +417,7 @@ def check_callsite(stmt, parser, funcname, format_idx, varargs_idx, with_size_t)
                             loc = vararg.location
                         else:
                             loc = stmt.loc
-                        gcc.warning(loc,
-                                    str(err))
-                        sys.stderr.write(err.extra_info())
+                        err.emit_as_warning(loc)
 
     def maybe_check_callsite(stmt):
         if stmt.fndecl:

testcpychecker.py

@@ -182,11 +182,10 @@ def test_not_enough_varargs(self):
 """
         self.assertFindsError(src,
                               "$(SRCFILE): In function 'not_enough_varargs':\n"
-                              '$(SRCFILE):13:25: error: Not enough arguments in call to PyArg_ParseTuple with format string "i"\n'
+                              '$(SRCFILE):13:25: error: Not enough arguments in call to PyArg_ParseTuple with format string "i" [-Werror]\n'
                               '  expected 1 extra arguments:\n'
                               '    "int *" (pointing to 32 bits)\n'
-                              '  but got none\n'
-                              ' [-Werror]\n')
+                              '  but got none\n')
 
     def test_too_many_varargs(self):
         src = """
@@ -202,13 +201,12 @@ def test_too_many_varargs(self):
 """
         self.assertFindsError(src,
                               "$(SRCFILE): In function 'too_many_varargs':\n"
-                              '$(SRCFILE):14:26: error: Too many arguments in call to PyArg_ParseTuple with format string "i"\n'
+                              '$(SRCFILE):14:26: error: Too many arguments in call to PyArg_ParseTuple with format string "i" [-Werror]\n'
                               '  expected 1 extra arguments:\n'
                               '    "int *" (pointing to 32 bits)\n'
                               '  but got 2:\n'
                               '    "int *" (pointing to 32 bits)\n'
-                              '    "int *" (pointing to 32 bits)\n'
-                              ' [-Werror]\n')
+                              '    "int *" (pointing to 32 bits)\n')
 
     def test_correct_usage(self):
         src = """
@@ -528,11 +526,10 @@ def test_not_enough_varargs(self):
 """
         self.assertFindsError(src,
                               "$(SRCFILE): In function 'not_enough_varargs':\n"
-                              '$(SRCFILE):13:5: error: Not enough arguments in call to Py_BuildValue with format string "i"\n'
+                              '$(SRCFILE):13:5: error: Not enough arguments in call to Py_BuildValue with format string "i" [-Werror]\n'
                               '  expected 1 extra arguments:\n'
                               '    "int"\n'
-                              '  but got none\n'
-                              ' [-Werror]\n')
+                              '  but got none\n')
 
     def test_too_many_varargs(self):
         src = """
@@ -544,13 +541,12 @@ def test_too_many_varargs(self):
 """
         self.assertFindsError(src,
                               "$(SRCFILE): In function 'too_many_varargs':\n"
-                              '$(SRCFILE):13:5: error: Too many arguments in call to Py_BuildValue with format string "i"\n'
+                              '$(SRCFILE):13:5: error: Too many arguments in call to Py_BuildValue with format string "i" [-Werror]\n'
                               '  expected 1 extra arguments:\n'
                               '    "int"\n'
                               '  but got 2:\n'
                               '    "int"\n'
-                              '    "int"\n'
-                              ' [-Werror]\n')
+                              '    "int"\n')
 
     def test_correct_usage(self):
         src = """

tests/cpychecker/PyArg_ParseTuple/incorrect_converters/stderr.txt

@@ -1,17 +1,15 @@
 In function 'incorrect_usages_of_converter':
-tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:36:nn: warning: Not enough arguments in call to PyArg_ParseTuple with format string "O&"
+tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:36:nn: warning: Not enough arguments in call to PyArg_ParseTuple with format string "O&" [enabled by default]
   expected 2 extra arguments:
     "int (converter)(PyObject *, T*)" for some type T
     "T*" for some type T
   but got none
- [enabled by default]
-tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:39:nn: warning: Not enough arguments in call to PyArg_ParseTuple with format string "O&"
+tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:39:nn: warning: Not enough arguments in call to PyArg_ParseTuple with format string "O&" [enabled by default]
   expected 2 extra arguments:
     "int (converter)(PyObject *, T*)" for some type T
     "T*" for some type T
   but got 1:
     "int"
- [enabled by default]
 tests/cpychecker/PyArg_ParseTuple/incorrect_converters/input.c:44:nn: warning: Mismatching type in call to PyArg_ParseTuple with format code "O&" [enabled by default]
   argument 3 ("42") had type
     "int"