Bug pylint 2436

ChangeLog

@@ -6,6 +6,11 @@ What's New in astroid 2.2.0?
 ============================
 Release Date: TBA
 
+* Fix a bug concerning inference of unary operators on numpy types and
+inference of calls to numpy function that should not return Tuple or List
+instances.
+
+  Close PyCQA/pylint#2436
 
 * Fix a crash with ``typing.NamedTuple`` and empty fields. Close PyCQA/pylint#2745
 

astroid/brain/brain_numpy.py

@@ -8,6 +8,7 @@
 
 """Astroid hooks for numpy."""
 
+import functools
 import astroid
 
 
@@ -270,6 +271,7 @@ def __init__(self, obj, align=False, copy=False):
             self.type = None
 
         def newbyteorder(self, new_order='S'): return any
+        def __neg__(self): return any
 
 
     class ndarray(object):
@@ -291,6 +293,9 @@ def __init__(self, shape, dtype=float, buffer=None, offset=0,
             self.size = None
             self.strides = None
 
+        def __neg__(self): return any
+        def __inv__(self): return any
+        def __invert__(self): return any
         def all(self): return any
         def any(self): return any
         def argmax(self): return any
@@ -356,7 +361,8 @@ def __init__(self, weekmask='1111100', holidays=None):
 
     class flexible(generic): pass
     class bool_(generic): pass
-    class number(generic): pass
+    class number(generic):
+        def __neg__(self): return any
     class datetime64(generic): pass
 
 
@@ -476,6 +482,69 @@ def sum(a, axis=None, dtype=None, out=None, keepdims=None):
     )
 
 
+def _looks_like_numpy_function(func_name, numpy_module_name, node):
+    """
+    Return True if the current node correspond to the function inside
+    the numpy module in parameters
+
+    :param node: the current node
+    :type node: FunctionDef
+    :param func_name: name of the function
+    :type func_name: str
+    :param numpy_module_name: name of the numpy module
+    :type numpy_module_name: str
+    :return: True if the current node correspond to the function looked for
+    :rtype: bool
+    """
+    return node.name == func_name and node.parent.name == numpy_module_name
+
+
+def numpy_function_infer_call_result(node):
+    """
+    A wrapper around infer_call_result method bounded to the node.
+
+    :param node: the node which infer_call_result should be filtered
+    :type node: FunctionDef
+    :return: a function that filter the results of the call to node.infer_call_result
+    :rtype: function
+    """
+    #  Put the origin infer_call_result method into the closure
+    origin_infer_call_result = node.infer_call_result
+
+    def infer_call_result_wrapper(caller=None, context=None):
+        """
+        Call the origin infer_call_result method bounded to the node instance and
+        filter the results to remove List and Tuple instances
+        """
+        unfiltered_infer_call_result = origin_infer_call_result(caller, context)
+        return (
+            x
+            for x in unfiltered_infer_call_result
+            if not isinstance(x, (astroid.List, astroid.Tuple))
+        )
+
+    return infer_call_result_wrapper
+
+
+def _replace_numpy_function_infer_call_result(node, context=None):
+    node.infer_call_result = numpy_function_infer_call_result(node)
+    return
+
+
+astroid.MANAGER.register_transform(
+    astroid.FunctionDef,
+    _replace_numpy_function_infer_call_result,
+    functools.partial(
+        _looks_like_numpy_function, "linspace", "numpy.core.function_base"
+    ),
+)
+
+astroid.MANAGER.register_transform(
+    astroid.FunctionDef,
+    _replace_numpy_function_infer_call_result,
+    functools.partial(_looks_like_numpy_function, "array", "numpy.core.records"),
+)
+
 astroid.register_module_extender(
     astroid.MANAGER, "numpy.core.umath", numpy_core_umath_transform
 )

astroid/tests/unittest_brain_numpy.py

@@ -17,6 +17,7 @@
 
 from astroid import builder
 from astroid import nodes
+from astroid import node_classes
 
 
 class SubTestWrapper(unittest.TestCase):
@@ -573,6 +574,87 @@ def test_generic_types_have_attributes(self):
                     with self.subTest(attr=attr):
                         self.assertNotEqual(len(inferred.getattr(attr)), 0)
 
+    def test_number_types_have_unary_operators(self):
+        """
+        Test that number types have unary operators
+        """
+        unary_ops = ("__neg__",)
+
+        for type_ in (
+            "float64",
+            "float96",
+            "floating",
+            "int16",
+            "int32",
+            "int32",
+            "int64",
+            "int8",
+            "integer",
+            "number",
+            "signedinteger",
+            "uint16",
+            "uint32",
+            "uint32",
+            "uint64",
+            "uint8",
+            "unsignedinteger",
+        ):
+            with self.subTest(typ=type_):
+                inferred = self._inferred_numpy_attribute(type_)
+                for attr in unary_ops:
+                    with self.subTest(attr=attr):
+                        self.assertNotEqual(len(inferred.getattr(attr)), 0)
+
+    def test_array_types_have_unary_operators(self):
+        """
+        Test that array types have unary operators
+        """
+        unary_ops = ("__neg__", "__inv__", "__invert__")
+
+        for type_ in ("ndarray",):
+            with self.subTest(typ=type_):
+                inferred = self._inferred_numpy_attribute(type_)
+                for attr in unary_ops:
+                    with self.subTest(attr=attr):
+                        self.assertNotEqual(len(inferred.getattr(attr)), 0)
+
+
+@unittest.skipUnless(HAS_NUMPY, "This test requires the numpy library.")
+class NumpyBrainFunctionReturningArrayTest(SubTestWrapper):
+    """
+    Test that calls to numpy functions returning arrays are correctly inferred
+    """
+
+    def _inferred_numpy_func_call(self, func_name, *func_args):
+        node = builder.extract_node(
+            """
+        import numpy as np
+        func = np.{:s}
+        func({:s})
+        """.format(
+                func_name, ",".join(func_args)
+            )
+        )
+        return node.infer()
+
+    def test_numpy_function_calls_not_inferred_as_list(self):
+        """
+        Test that some calls to numpy functions are not inferred as list nor tuple
+        """
+        for func_ in (("array", "[1, 2]"),):
+            with self.subTest(typ=func_):
+                for inferred in self._inferred_numpy_func_call(*func_):
+                    self.assertFalse(isinstance(inferred, node_classes.List))
+
+    def test_numpy_function_calls_not_inferred_as_tuple(self):
+        """
+        Test that some calls to numpy functions are not inferred as list nor tuple
+        """
+        for func_ in (("array", "(1, 2)"), ("linspace", "1, 100")):
+            with self.subTest(typ=func_):
+                for inferred in self._inferred_numpy_func_call(*func_):
+                    self.assertFalse(isinstance(inferred, node_classes.Tuple))
+
 
 if __name__ == "__main__":
     unittest.main()