pylint: upgrade to 1.4.0

third_party/pylint/checkers/typecheck.py

 # Copyright (c) 2006-2013 LOGILAB S.A. (Paris, FRANCE).
 # 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.
 """try to find more bugs in the code using astroid inference capabilities
 """
 
 import re
 import shlex
 
 import astroid
 from astroid import InferenceError, NotFoundError, YES, Instance
 from astroid.bases import BUILTINS
 
-from pylint.interfaces import IAstroidChecker
+from pylint.interfaces import IAstroidChecker, INFERENCE, INFERENCE_FAILURE
 from pylint.checkers import BaseChecker
-from pylint.checkers.utils import safe_infer, is_super, check_messages
+from pylint.checkers.utils import (
+    safe_infer, is_super,
+    check_messages, decorated_with_property)
 
 MSGS = {
     'E1101': ('%s %r has no %r member',
               'no-member',
-              'Used when a variable is accessed for an unexistent member.'),
+              'Used when a variable is accessed for an unexistent member.',
+              {'old_names': [('E1103', 'maybe-no-member')]}),
     'E1102': ('%s is not callable',
               'not-callable',
               'Used when an object being called has been inferred to a non \
               callable object'),
-    'E1103': ('%s %r has no %r member (but some types could not be inferred)',
-              'maybe-no-member',
-              'Used when a variable is accessed for an unexistent member, but \
-              astroid was not able to interpret all possible types of this \
-              variable.'),
     'E1111': ('Assigning to function call which doesn\'t return',
               'assignment-from-no-return',
               'Used when an assignment is done on a function call but the \
               inferred function doesn\'t return anything.'),
     'W1111': ('Assigning to function call which only returns None',
               'assignment-from-none',
               'Used when an assignment is done on a function call but the \
               inferred function returns nothing but None.'),
 
     'E1120': ('No value for argument %s in %s call',
               'no-value-for-parameter',
               'Used when a function call passes too few arguments.'),
     'E1121': ('Too many positional arguments for %s call',
               'too-many-function-args',
               'Used when a function call passes too many positional \
               arguments.'),
-    'E1122': ('Duplicate keyword argument %r in %s call',
-              'duplicate-keyword-arg',
-              'Used when a function call passes the same keyword argument \
-              multiple times.',
-              {'maxversion': (2, 6)}),
     'E1123': ('Unexpected keyword argument %r in %s call',
               'unexpected-keyword-arg',
               'Used when a function call passes a keyword argument that \
               doesn\'t correspond to one of the function\'s parameter names.'),
     'E1124': ('Argument %r passed by position and keyword in %s call',
               'redundant-keyword-arg',
               'Used when a function call would result in assigning multiple \
               values to a function parameter, one value from a positional \
               argument and one from a keyword argument.'),
     'E1125': ('Missing mandatory keyword argument %r in %s call',
@@ skipping 111 matching lines @@
         if self.config.zope:
             self.generated_members.extend(('REQUEST', 'acl_users', 'aq_parent'))
 
     def visit_assattr(self, node):
         if isinstance(node.ass_type(), astroid.AugAssign):
             self.visit_getattr(node)
 
     def visit_delattr(self, node):
         self.visit_getattr(node)
 
-    @check_messages('no-member', 'maybe-no-member')
+    @check_messages('no-member')
     def visit_getattr(self, node):
         """check that the accessed attribute exists
 
         to avoid to much false positives for now, we'll consider the code as
         correct if a single of the inferred nodes has the accessed attribute.
 
         function/method, super call and metaclasses are ignored
         """
         # generated_members may containt regular expressions
         # (surrounded by quote `"` and followed by a comma `,`)
@@ skipping 41 matching lines @@
                 # XXX method / function
                 continue
             except NotFoundError:
                 if isinstance(owner, astroid.Function) and owner.decorators:
                     continue
                 if isinstance(owner, Instance) and owner.has_dynamic_getattr():
                     continue
                 # explicit skipping of module member access
                 if owner.root().name in self.config.ignored_modules:
                     continue
+                if isinstance(owner, astroid.Class):
+                    # Look up in the metaclass only if the owner is itself
+                    # a class.
+                    # TODO: getattr doesn't return by default members
+                    # from the metaclass, because handling various cases
+                    # of methods accessible from the metaclass itself
+                    # and/or subclasses only is too complicated for little to
+                    # no benefit.
+                    metaclass = owner.metaclass()
+                    try:
+                        if metaclass and metaclass.getattr(node.attrname):
+                            continue
+                    except NotFoundError:
+                        pass
                 missingattr.add((owner, name))
                 continue
             # stop on the first found
             break
         else:
             # we have not found any node with the attributes, display the
             # message for infered nodes
             done = set()
             for owner, name in missingattr:
                 if isinstance(owner, Instance):
                     actual = owner._proxied
                 else:
                     actual = owner
                 if actual in done:
                     continue
                 done.add(actual)
-                if inference_failure:
-                    msgid = 'maybe-no-member'
-                else:
-                    msgid = 'no-member'
-                self.add_message(msgid, node=node,
+                confidence = INFERENCE if not inference_failure else INFERENCE_FAILURE
+                self.add_message('no-member', node=node,
                                  args=(owner.display_type(), name,
-                                       node.attrname))
+                                       node.attrname),
+                                 confidence=confidence)
 
     @check_messages('assignment-from-no-return', 'assignment-from-none')
     def visit_assign(self, node):
         """check that if assigning to a function call, the function is
         possibly returning something valuable
         """
         if not isinstance(node.value, astroid.CallFunc):
             return
         function_node = safe_infer(node.value.func)
         # skip class, generator and incomplete function definition
@@ skipping 36 matching lines @@
         klass = safe_infer(expr)
         if (klass is None or klass is astroid.YES or
                 not isinstance(klass, astroid.Instance)):
             return
 
         try:
             attrs = klass._proxied.getattr(node.func.attrname)
         except astroid.NotFoundError:
             return
 
-        stop_checking = False
         for attr in attrs:
             if attr is astroid.YES:
                 continue
-            if stop_checking:
-                break
             if not isinstance(attr, astroid.Function):
                 continue
 
             # Decorated, see if it is decorated with a property
-            if not attr.decorators:
-                continue
-            for decorator in attr.decorators.nodes:
-                if not isinstance(decorator, astroid.Name):
-                    continue
-                try:
-                    for infered in decorator.infer():
-                        property_like = False
-                        if isinstance(infered, astroid.Class):
-                            if (infered.root().name == BUILTINS and
-                                    infered.name == 'property'):
-                                property_like = True
-                            else:
-                                for ancestor in infered.ancestors():
-                                    if (ancestor.name == 'property' and
-                                            ancestor.root().name == BUILTINS):
-                                        property_like = True
-                                        break
-                            if property_like:
-                                self.add_message('not-callable', node=node,
-                                                 args=node.func.as_string())
-                                stop_checking = True
-                                break
-                except InferenceError:
-                    pass
-                if stop_checking:
-                    break
+            if decorated_with_property(attr):
+                self.add_message('not-callable', node=node,
+                                 args=node.func.as_string())
+                break
 
     @check_messages(*(list(MSGS.keys())))
     def visit_callfunc(self, node):
         """check that called functions/methods are inferred to callable objects,
         and that the arguments passed to the function match the parameters in
         the inferred function's definition
         """
         # Build the set of keyword arguments, checking for duplicate keywords,
         # and count the positional arguments.
         keyword_args = set()
         num_positional_args = 0
         for arg in node.args:
             if isinstance(arg, astroid.Keyword):
-                keyword = arg.arg
-                if keyword in keyword_args:
-                    self.add_message('duplicate-keyword-arg', node=node,
-                                     args=(keyword, 'function'))
-                keyword_args.add(keyword)
+                keyword_args.add(arg.arg)
             else:
                 num_positional_args += 1
 
         called = safe_infer(node.func)
         # only function, generator and object defining __call__ are allowed
         if called is not None and not called.callable():
             self.add_message('not-callable', node=node,
                              args=node.func.as_string())
 
         self._check_uninferable_callfunc(node)
@@ skipping 141 matching lines @@
     @check_messages('invalid-sequence-index')
     def visit_index(self, node):
         if not node.parent or not hasattr(node.parent, "value"):
             return
 
         # Look for index operations where the parent is a sequence type.
         # If the types can be determined, only allow indices to be int,
         # slice or instances with __index__.
 
         parent_type = safe_infer(node.parent.value)
-
         if not isinstance(parent_type, (astroid.Class, astroid.Instance)):
             return
 
         # Determine what method on the parent this index will use
         # The parent of this node will be a Subscript, and the parent of that
         # node determines if the Subscript is a get, set, or delete operation.
         operation = node.parent.parent
         if isinstance(operation, astroid.Assign):
             methodname = '__setitem__'
         elif isinstance(operation, astroid.Delete):
             methodname = '__delitem__'
         else:
             methodname = '__getitem__'
 
         # Check if this instance's __getitem__, __setitem__, or __delitem__, as
         # appropriate to the statement, is implemented in a builtin sequence
         # type. This way we catch subclasses of sequence types but skip classes
         # that override __getitem__ and which may allow non-integer indices.
         try:
             methods = parent_type.getattr(methodname)
             if methods is astroid.YES:
                 return
             itemmethod = methods[0]
         except (astroid.NotFoundError, IndexError):
             return
 
         if not isinstance(itemmethod, astroid.Function):
             return
-
         if itemmethod.root().name != BUILTINS:
             return
-
         if not itemmethod.parent:
             return
-
         if itemmethod.parent.name not in SEQUENCE_TYPES:
             return
 
         # For ExtSlice objects coming from visit_extslice, no further
         # inference is necessary, since if we got this far the ExtSlice
         # is an error.
         if isinstance(node, astroid.ExtSlice):
             index_type = node
         else:
             index_type = safe_infer(node)
-
         if index_type is None or index_type is astroid.YES:
             return
 
         # Constants must be of type int
         if isinstance(index_type, astroid.Const):
             if isinstance(index_type.value, int):
                 return
         # Instance values must be int, slice, or have an __index__ method
         elif isinstance(index_type, astroid.Instance):
             if index_type.pytype() in (BUILTINS + '.int', BUILTINS + '.slice'):
                 return
-
             try:
                 index_type.getattr('__index__')
                 return
             except astroid.NotFoundError:
                 pass
 
         # Anything else is an error
         self.add_message('invalid-sequence-index', node=node)
 
     @check_messages('invalid-slice-index')
     def visit_slice(self, node):
         # Check the type of each part of the slice
         for index in (node.lower, node.upper, node.step):
             if index is None:
                 continue
 
             index_type = safe_infer(index)
-
             if index_type is None or index_type is astroid.YES:
                 continue
 
             # Constants must of type int or None
             if isinstance(index_type, astroid.Const):
                 if isinstance(index_type.value, (int, type(None))):
                     continue
             # Instance values must be of type int, None or an object
             # with __index__
             elif isinstance(index_type, astroid.Instance):
                 if index_type.pytype() in (BUILTINS + '.int',
                                            BUILTINS + '.NoneType'):
                     continue
 
                 try:
                     index_type.getattr('__index__')
                     return
                 except astroid.NotFoundError:
                     pass
 
             # Anything else is an error
             self.add_message('invalid-slice-index', node=node)
 
 def register(linter):
     """required method to auto register this checker """
     linter.register_checker(TypeChecker(linter))