pylint: upgrade to 1.4.0

third_party/pylint/checkers/strings.py

 # Copyright (c) 2009-2010 Arista Networks, Inc. - James Lingard
 # Copyright (c) 2004-2013 LOGILAB S.A. (Paris, FRANCE).
 # Copyright 2012 Google Inc.
 #
 # http://www.logilab.fr/ -- mailto:contact@logilab.fr
 # This program is free software; you can redistribute it and/or modify it under
 # the terms of the GNU General Public License as published by the Free Software
 # Foundation; either version 2 of the License, or (at your option) any later
 # version.
 #
 # This program is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details
 #
 # You should have received a copy of the GNU General Public License along with
 # this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """Checker for string formatting operations.
 """
 
 import sys
 import tokenize
 import string
-try:
-    import numbers
-except ImportError:
-    numbers = None
+import numbers
 
 import astroid
 
 from pylint.interfaces import ITokenChecker, IAstroidChecker, IRawChecker
 from pylint.checkers import BaseChecker, BaseTokenChecker
 from pylint.checkers import utils
 from pylint.checkers.utils import check_messages
 
+import six
+
+
 _PY3K = sys.version_info[:2] >= (3, 0)
 _PY27 = sys.version_info[:2] == (2, 7)
 
 MSGS = {
     'E1300': ("Unsupported format character %r (%#02x) at index %d",
               "bad-format-character",
               "Used when a unsupported format character is used in a format\
               string."),
     'E1301': ("Format string ends in middle of conversion specifier",
               "truncated-format-string",
@@ skipping 92 matching lines @@
         return keyname, _field_iterator_convertor(fielditerator)
 
 
 def collect_string_fields(format_string):
     """ Given a format string, return an iterator
     of all the valid format fields. It handles nested fields
     as well.
     """
 
     formatter = string.Formatter()
-    parseiterator = formatter.parse(format_string)
     try:
+        parseiterator = formatter.parse(format_string)
         for result in parseiterator:
             if all(item is None for item in result[1:]):
                 # not a replacement format
                 continue
             name = result[1]
             nested = result[2]
             yield name
             if nested:
                 for field in collect_string_fields(nested):
                     yield field
@@ skipping 14 matching lines @@
     num_args = 0
     manual_pos_arg = set()
     for name in collect_string_fields(format_string):
         if name and str(name).isdigit():
             manual_pos_arg.add(str(name))
         elif name:
             keyname, fielditerator = split_format_field_names(name)
             if isinstance(keyname, numbers.Number):
                 # In Python 2 it will return long which will lead
                 # to different output between 2 and 3
+                manual_pos_arg.add(keyname)
                 keyname = int(keyname)
             keys.append((keyname, list(fielditerator)))
         else:
             num_args += 1
     return keys, num_args, len(manual_pos_arg)
 
 def get_args(callfunc):
     """ Get the arguments from the given `CallFunc` node.
     Return a tuple, where the first element is the
     number of positional arguments and the second element
@@ skipping 32 matching lines @@
     msgs = MSGS
 
     @check_messages(*(MSGS.keys()))
     def visit_binop(self, node):
         if node.op != '%':
             return
         left = node.left
         args = node.right
 
         if not (isinstance(left, astroid.Const)
-                and isinstance(left.value, basestring)):
+                and isinstance(left.value, six.string_types)):
             return
         format_string = left.value
         try:
             required_keys, required_num_args = \
                 utils.parse_format_string(format_string)
-        except utils.UnsupportedFormatCharacter, e:
+        except utils.UnsupportedFormatCharacter as e:
             c = format_string[e.index]
             self.add_message('bad-format-character',
                              node=node, args=(c, ord(c), e.index))
             return
         except utils.IncompleteFormatString:
             self.add_message('truncated-format-string', node=node)
             return
         if required_keys and required_num_args:
             # The format string uses both named and unnamed format
             # specifiers.
             self.add_message('mixed-format-string', node=node)
         elif required_keys:
             # The format string uses only named format specifiers.
             # Check that the RHS of the % operator is a mapping object
             # that contains precisely the set of keys required by the
             # format string.
             if isinstance(args, astroid.Dict):
                 keys = set()
                 unknown_keys = False
                 for k, _ in args.items:
                     if isinstance(k, astroid.Const):
                         key = k.value
-                        if isinstance(key, basestring):
+                        if isinstance(key, six.string_types):
                             keys.add(key)
                         else:
                             self.add_message('bad-format-string-key',
                                              node=node, args=key)
                     else:
                         # One of the keys was something other than a
                         # constant.  Since we can't tell what it is,
                         # supress checks for missing keys in the
                         # dictionary.
                         unknown_keys = True
@@ skipping 62 matching lines @@
                 if _PY27 or _PY3K:
                     self._check_new_format(node, func)
 
     def _check_new_format(self, node, func):
         """ Check the new string formatting. """
         # TODO: skip (for now) format nodes which don't have
         #       an explicit string on the left side of the format operation.
         #       We do this because our inference engine can't properly handle
         #       redefinitions of the original string.
         #       For more details, see issue 287.
-        if not isinstance(node.func.expr, astroid.Const):
+        #
+        # Note that there may not be any left side at all, if the format method
+        # has been assigned to another variable. See issue 351. For example:
+        #
+        #    fmt = 'some string {}'.format
+        #    fmt('arg')
+        if (isinstance(node.func, astroid.Getattr)
+                and not isinstance(node.func.expr, astroid.Const)):
             return
         try:
-            strnode = func.bound.infer().next()
+            strnode = next(func.bound.infer())
         except astroid.InferenceError:
             return
         if not isinstance(strnode, astroid.Const):
             return
         if node.starargs or node.kwargs:
             # TODO: Don't complicate the logic, skip these for now.
             return
         try:
             positional, named = get_args(node)
         except astroid.InferenceError:
             return
         try:
             fields, num_args, manual_pos = parse_format_method_string(strnode.value)
         except utils.IncompleteFormatString:
             self.add_message('bad-format-string', node=node)
             return
 
-        manual_fields = set(field[0] for field in fields
-                            if isinstance(field[0], numbers.Number))
         named_fields = set(field[0] for field in fields
-                           if isinstance(field[0], basestring))
+                           if isinstance(field[0], six.string_types))
         if num_args and manual_pos:
             self.add_message('format-combined-specification',
                              node=node)
             return
 
         check_args = False
         # Consider "{[0]} {[1]}" as num_args.
         num_args += sum(1 for field in named_fields
                         if field == '')
         if named_fields:
@@ skipping 18 matching lines @@
                     # This means that the format strings accepts both
                     # positional and named fields and we should warn
                     # when one of the them is missing or is extra.
                     check_args = True
         else:
             check_args = True
         if check_args:
             # num_args can be 0 if manual_pos is not.
             num_args = num_args or manual_pos
             if positional > num_args:
-                # We can have two possibilities:
-                # * "{0} {1}".format(a, b)
-                # * "{} {} {}".format(a, b, c, d)
-                # We can check the manual keys for the first one.
-                if len(manual_fields) != positional:
-                    self.add_message('too-many-format-args', node=node)
+                self.add_message('too-many-format-args', node=node)
             elif positional < num_args:
                 self.add_message('too-few-format-args', node=node)
 
         self._check_new_format_specifiers(node, fields, named)
 
     def _check_new_format_specifiers(self, node, fields, named):
         """
         Check attribute and index access in the format
         string ("{0.a}" and "{0[a]}").
         """
@@ skipping 10 matching lines @@
                     argname = utils.get_argument_from_call(node, key)
                 except utils.NoSuchArgumentError:
                     continue
             else:
                 if key not in named:
                     continue
                 argname = named[key]
             if argname in (astroid.YES, None):
                 continue
             try:
-                argument = argname.infer().next()
+                argument = next(argname.infer())
             except astroid.InferenceError:
                 continue
             if not specifiers or argument is astroid.YES:
                 # No need to check this key if it doesn't
                 # use attribute / item access
                 continue
             if argument.parent and isinstance(argument.parent, astroid.Arguments):
-                # Check to see if our argument is kwarg or vararg,
-                # and skip the check for this argument if so, because when inferring,
-                # astroid will return empty objects (dicts and tuples) and
-                # that can lead to false positives.
-                if argname.name in (argument.parent.kwarg, argument.parent.vararg):
-                    continue
+                # Ignore any object coming from an argument,
+                # because we can't infer its value properly.
+                continue
             previous = argument
             parsed = []
             for is_attribute, specifier in specifiers:
                 if previous is astroid.YES:
                     break
                 parsed.append((is_attribute, specifier))
                 if is_attribute:
                     try:
                         previous = previous.getattr(specifier)[0]
                     except astroid.NotFoundError:
@@ skipping 23 matching lines @@
                         except astroid.NotFoundError:
                             warn_error = True
                     if warn_error:
                         path = get_access_path(key, parsed)
                         self.add_message('invalid-format-index',
                                          args=(specifier, path),
                                          node=node)
                         break
 
                 try:
-                    previous = previous.infer().next()
+                    previous = next(previous.infer())
                 except astroid.InferenceError:
                     # can't check further if we can't infer it
                     break
 
 
 
 class StringConstantChecker(BaseTokenChecker):
     """Check string literals"""
     __implements__ = (ITokenChecker, IRawChecker)
     name = 'string_constant'
@@ skipping 18 matching lines @@
     # prefer a separate warning where they occur.  \0 should be allowed.
 
     # Characters that have a special meaning after a backslash but only in
     # Unicode strings.
     UNICODE_ESCAPE_CHARACTERS = 'uUN'
 
     def process_module(self, module):
         self._unicode_literals = 'unicode_literals' in module.future_imports
 
     def process_tokens(self, tokens):
-        for (tok_type, token, (start_row, start_col), _, _) in tokens:
+        for (tok_type, token, (start_row, _), _, _) in tokens:
             if tok_type == tokenize.STRING:
                 # 'token' is the whole un-parsed token; we can look at the start
                 # of it to see whether it's a raw or unicode string etc.
-                self.process_string_token(token, start_row, start_col)
+                self.process_string_token(token, start_row)
 
-    def process_string_token(self, token, start_row, start_col):
+    def process_string_token(self, token, start_row):
         for i, c in enumerate(token):
             if c in '\'\"':
                 quote_char = c
                 break
+        # pylint: disable=undefined-loop-variable
         prefix = token[:i].lower() #  markers like u, b, r.
         after_prefix = token[i:]
         if after_prefix[:3] == after_prefix[-3:] == 3 * quote_char:
             string_body = after_prefix[3:-3]
         else:
             string_body = after_prefix[1:-1]  # Chop off quotes
         # No special checks on raw strings at the moment.
         if 'r' not in prefix:
-            self.process_non_raw_string_token(prefix, string_body,
-                                              start_row, start_col)
+            self.process_non_raw_string_token(prefix, string_body, start_row)
 
-    def process_non_raw_string_token(self, prefix, string_body, start_row,
-                                     start_col):
+    def process_non_raw_string_token(self, prefix, string_body, start_row):
         """check for bad escapes in a non-raw string.
 
         prefix: lowercase string of eg 'ur' string prefix markers.
         string_body: the un-parsed body of the string, not including the quote
         marks.
         start_row: integer line number in the source.
-        start_col: integer column number in the source.
         """
         # Walk through the string; if we see a backslash then escape the next
         # character, and skip over it.  If we see a non-escaped character,
         # alert, and continue.
         #
         # Accept a backslash when it escapes a backslash, or a quote, or
         # end-of-line, or one of the letters that introduce a special escape
         # sequence <http://docs.python.org/reference/lexical_analysis.html>
         #
         # TODO(mbp): Maybe give a separate warning about the rarely-used
@@ skipping 26 matching lines @@
             # character can never be the start of a new backslash escape.
             i += 2
 
 
 
 def register(linter):
     """required method to auto register this checker """
     linter.register_checker(StringFormatChecker(linter))
     linter.register_checker(StringMethodsChecker(linter))
     linter.register_checker(StringConstantChecker(linter))