Add a class attribute hook to the plugin system

This adds a hook to modify attributes on *classes* (as opposed to the existing attribute hook, which is for attributes on *instances*). This also adds a test to demonstrate the new behavior. The modifications and added tests were modeled off of python@3acbf3f. This is intended to solve python#9645

Author: FuegoFro

mypy/checkmember.py

@@ -778,6 +778,13 @@ def analyze_class_attribute_access(itype: Instance,
         if not mx.is_lvalue:
             result = analyze_descriptor_access(mx.original_type, result, mx.builtin_type,
                                                mx.msg, mx.context, chk=mx.chk)
+
+        # Call the class attribute hook before returning.
+        fullname = '{}.{}'.format(info.fullname, name)
+        hook = mx.chk.plugin.get_class_attribute_hook(fullname)
+        if hook:
+            result = hook(AttributeContext(get_proper_type(mx.original_type),
+                                           result, mx.context, mx.chk))
         return result
     elif isinstance(node.node, Var):
         mx.not_ready_callback(name, mx.context)

mypy/plugin.py

@@ -616,10 +616,10 @@ def get_method_hook(self, fullname: str
 
     def get_attribute_hook(self, fullname: str
                            ) -> Optional[Callable[[AttributeContext], Type]]:
-        """Adjust type of a class attribute.
+        """Adjust type of an instance attribute.
 
-        This method is called with attribute full name using the class where the attribute was
-        defined (or Var.info.fullname for generated attributes).
+        This method is called with attribute full name using the class of the instance where
+        the attribute was defined (or Var.info.fullname for generated attributes).
 
         For classes without __getattr__ or __getattribute__, this hook is only called for
         names of fields/properties (but not methods) that exist in the instance MRO.
@@ -646,6 +646,25 @@ class Derived(Base):
         """
         return None
 
+    def get_class_attribute_hook(self, fullname: str
+                                 ) -> Optional[Callable[[AttributeContext], Type]]:
+        """
+        Adjust type of a class attribute.
+
+        This method is called with attribute full name using the class where the attribute was
+        defined (or Var.info.fullname for generated attributes).
+
+        For example:
+
+            class Cls:
+                x: Any
+
+            Cls.x
+
+        get_class_attribute_hook is called with '__main__.Cls.x'.
+        """
+        return None
+
     def get_class_decorator_hook(self, fullname: str
                                  ) -> Optional[Callable[[ClassDefContext], None]]:
         """Update class definition for given class decorators.
@@ -767,6 +786,10 @@ def get_attribute_hook(self, fullname: str
                            ) -> Optional[Callable[[AttributeContext], Type]]:
         return self._find_hook(lambda plugin: plugin.get_attribute_hook(fullname))
 
+    def get_class_attribute_hook(self, fullname: str
+                                 ) -> Optional[Callable[[AttributeContext], Type]]:
+        return self._find_hook(lambda plugin: plugin.get_class_attribute_hook(fullname))
+
     def get_class_decorator_hook(self, fullname: str
                                  ) -> Optional[Callable[[ClassDefContext], None]]:
         return self._find_hook(lambda plugin: plugin.get_class_decorator_hook(fullname))

test-data/unit/check-custom-plugin.test

@@ -783,3 +783,15 @@ reveal_type(dynamic_signature(1))  # N: Revealed type is "builtins.int"
 [file mypy.ini]
 \[mypy]
 plugins=<ROOT>/test-data/unit/plugins/function_sig_hook.py
+
+[case testClassAttrPluginFile]
+# flags: --config-file tmp/mypy.ini
+
+class Cls:
+    attr = 'test'
+
+reveal_type(Cls.attr)  # N: Revealed type is 'builtins.int'
+reveal_type(Cls().attr)  # N: Revealed type is 'builtins.str'
+[file mypy.ini]
+\[mypy]
+plugins=<ROOT>/test-data/unit/plugins/class_attr_hook.py

test-data/unit/plugins/class_attr_hook.py

@@ -0,0 +1,20 @@
+from typing import Callable, Optional, Type as TypingType
+
+from mypy.plugin import AttributeContext, Plugin
+from mypy.types import Type as MypyType
+
+
+class ClassAttrPlugin(Plugin):
+    def get_class_attribute_hook(self, fullname: str
+                                 ) -> Optional[Callable[[AttributeContext], MypyType]]:
+        if fullname == '__main__.Cls.attr':
+            return my_hook
+        return None
+
+
+def my_hook(ctx: AttributeContext) -> MypyType:
+    return ctx.api.named_generic_type('builtins.int', [])
+
+
+def plugin(_version: str) -> TypingType[Plugin]:
+    return ClassAttrPlugin