Bug pylint 4206

astroid/brain/brain_collections.py

@@ -68,7 +68,7 @@ def __rmul__(self, other): pass"""
     if PY39:
         base_deque_class += """
         @classmethod
-        def __class_getitem__(self, item): pass"""
+        def __class_getitem__(self, item): return cls"""
     return base_deque_class
 
 
@@ -77,7 +77,50 @@ def _ordered_dict_mock():
     class OrderedDict(dict):
         def __reversed__(self): return self[::-1]
         def move_to_end(self, key, last=False): pass"""
+    if PY39:
+        base_ordered_dict_class += """
+        @classmethod
+        def __class_getitem__(cls, item): return cls"""
     return base_ordered_dict_class
 
 
 astroid.register_module_extender(astroid.MANAGER, "collections", _collections_transform)
+
+
+PY39 = sys.version_info >= (3, 9)
+
+def _looks_like_subscriptable(node: astroid.nodes.ClassDef) -> bool:
+    """
+    Returns True if the node corresponds to a ClassDef of the Collections.abc module that
+    supports subscripting
+
+    :param node: ClassDef node
+    """
+    if node.qname().startswith('_collections_abc'):
+        try:
+            node.getattr('__class_getitem__')
+            return True
+        except:
+            pass
+    return False
+
+CLASS_GET_ITEM_TEMPLATE = """
+@classmethod
+def __class_getitem__(cls, item):
+    return cls
+"""
+
+def easy_class_getitem_inference(node, context=None):
+    # Here __class_getitem__ exists but is quite a mess to infer thus
+    # put instead an easy inference tip
+    func_to_add = astroid.extract_node(CLASS_GET_ITEM_TEMPLATE)
+    node.locals["__class_getitem__"] = [func_to_add]
+
+if PY39:
+    # Starting with Python39 some objects of the collection module are subscriptable
+    # thanks to the __class_getitem__ method but the way it is implemented in
+    # _collection_abc makes it difficult to infer. (We would have to handle AssignName inference in the 
+    # getitem method of the ClassDef class) Instead we put here a mock of the __class_getitem__ method
+    astroid.MANAGER.register_transform(
+        astroid.nodes.ClassDef, easy_class_getitem_inference, _looks_like_subscriptable
+    )

astroid/scoped_nodes.py

@@ -2617,7 +2617,20 @@ def getitem(self, index, context=None):
         try:
             methods = dunder_lookup.lookup(self, "__getitem__")
         except exceptions.AttributeInferenceError as exc:
-            raise exceptions.AstroidTypeError(node=self, context=context) from exc
+            if isinstance(self, ClassDef):
+                # subscripting a class definition may be 
+                # achieved thanks to __class_getitem__ method
+                # which is a classmethod defined in the class 
+                # that supports subscript and not in the metaclass
+                try:
+                    methods = self.getattr("__class_getitem__")
+                    # Here it is assumed that the __class_getitem__ node is
+                    # a FunctionDef. One possible improvment would be to deal
+                    # with more generic inference.
+                except exceptions.AttributeInferenceError:
+                    raise exceptions.AstroidTypeError(node=self, context=context) from exc
+            else:
+                raise exceptions.AstroidTypeError(node=self, context=context) from exc
 
         method = methods[0]
 

tests/unittest_brain.py

@@ -1211,25 +1211,18 @@ class CustomTD(TypedDict):
         assert len(typing_module.locals["TypedDict"]) == 1
         assert inferred_base == typing_module.locals["TypedDict"][0]
 
+    @staticmethod
+    def check_metaclass_is_abc(node: nodes.ClassDef):
+        meta = node.metaclass()
+        assert isinstance(meta, nodes.ClassDef)
+        assert meta.name == "ABCMeta"
+
     @test_utils.require_version("3.8")
     def test_typing_alias_type(self):
         """
         Test that the type aliased thanks to typing._alias function are
         correctly inferred.
         """
-
-        def check_metaclass(node: nodes.ClassDef):
-            meta = node.metaclass()
-            assert isinstance(meta, nodes.ClassDef)
-            assert meta.name == "ABCMeta_typing"
-            assert "ABCMeta" == meta.basenames[0]
-            assert meta.locals.get("__getitem__") is not None
-
-            abc_meta = next(meta.bases[0].infer())
-            assert isinstance(abc_meta, nodes.ClassDef)
-            assert abc_meta.name == "ABCMeta"
-            assert abc_meta.locals.get("__getitem__") is None
-
         node = builder.extract_node(
             """
         from typing import TypeVar, MutableSet
@@ -1242,12 +1235,11 @@ class Derived1(MutableSet[T]):
         """
         )
         inferred = next(node.infer())
-        check_metaclass(inferred)
+        self.check_metaclass_is_abc(inferred)
         assertEqualMro(
             inferred,
             [
                 "Derived1",
-                "MutableSet_typing",
                 "MutableSet",
                 "Set",
                 "Collection",
@@ -1266,36 +1258,17 @@ class Derived2(typing.OrderedDict[int, str]):
         """
         )
         inferred = next(node.infer())
-        check_metaclass(inferred)
+        self.assertIsNone(inferred.metaclass())
         assertEqualMro(
             inferred,
             [
                 "Derived2",
-                "OrderedDict_typing",
                 "OrderedDict",
                 "dict",
                 "object",
             ],
         )
 
-        node = builder.extract_node(
-            """
-        import typing
-        class Derived3(typing.Pattern[str]):
-            pass
-        """
-        )
-        inferred = next(node.infer())
-        check_metaclass(inferred)
-        assertEqualMro(
-            inferred,
-            [
-                "Derived3",
-                "Pattern",
-                "object",
-            ],
-        )
-
     @test_utils.require_version("3.8")
     def test_typing_alias_side_effects(self):
         """Test that typing._alias changes doesn't have unwanted consequences."""
@@ -1309,15 +1282,14 @@ class Derived(collections.abc.Iterator[int]):
         """
         )
         inferred = next(node.infer())
-        assert inferred.metaclass() is None  # Should this be ABCMeta?
+        self.check_metaclass_is_abc(inferred)
         assertEqualMro(
             inferred,
             [
                 "Derived",
-                # Should this be more?
-                # "Iterator_typing"?
-                # "Iterator",
-                # "object",
+                "Iterator",
+                "Iterable",
+                "object",
             ],
         )