Plugin to typecheck attrs-generated classes

mypy/nodes.py

@@ -1993,6 +1993,10 @@ class is generic then it will be a type constructor of higher kind.
     # needed during the semantic passes.)
     replaced = None  # type: TypeInfo
 
+    # This is a dictionary that will be serialized and un-serialized as is.
+    # It is useful for plugins to add their data to save in the cache.
+    metadata = None  # type: Dict[str, JsonDict]
+
     FLAGS = [
         'is_abstract', 'is_enum', 'fallback_to_any', 'is_named_tuple',
         'is_newtype', 'is_protocol', 'runtime_protocol'
@@ -2016,6 +2020,7 @@ def __init__(self, names: 'SymbolTable', defn: ClassDef, module_name: str) -> No
         self._cache = set()
         self._cache_proper = set()
         self.add_type_vars()
+        self.metadata = {}
 
     def add_type_vars(self) -> None:
         if self.defn.type_vars:
@@ -2218,6 +2223,7 @@ def serialize(self) -> JsonDict:
                 'typeddict_type':
                     None if self.typeddict_type is None else self.typeddict_type.serialize(),
                 'flags': get_flags(self, TypeInfo.FLAGS),
+                'metadata': self.metadata,
                 }
         return data
 
@@ -2244,6 +2250,7 @@ def deserialize(cls, data: JsonDict) -> 'TypeInfo':
                          else mypy.types.TupleType.deserialize(data['tuple_type']))
         ti.typeddict_type = (None if data['typeddict_type'] is None
                             else mypy.types.TypedDictType.deserialize(data['typeddict_type']))
+        ti.metadata = data['metadata']
         set_flags(ti, data['flags'])
         return ti
 
@@ -2612,3 +2619,10 @@ def check_arg_names(names: Sequence[Optional[str]], nodes: List[T], fail: Callab
             fail("Duplicate argument '{}' in {}".format(name, description), node)
             break
         seen_names.add(name)
+
+
+def is_class_var(expr: NameExpr) -> bool:
+    """Return whether the expression is ClassVar[...]"""
+    if isinstance(expr.node, Var):
+        return expr.node.is_classvar
+    return False

mypy/plugin.py

@@ -1,12 +1,17 @@
 """Plugin system for extending mypy."""
 
-from collections import OrderedDict
 from abc import abstractmethod
+from functools import partial
 from typing import Callable, List, Tuple, Optional, NamedTuple, TypeVar
 
-from mypy.nodes import Expression, StrExpr, IntExpr, UnaryExpr, Context, DictExpr, ClassDef
+import mypy.plugins.attrs
+from mypy.nodes import (
+    Expression, StrExpr, IntExpr, UnaryExpr, Context, DictExpr, ClassDef,
+    TypeInfo, SymbolTableNode
+)
+from mypy.tvar_scope import TypeVarScope
 from mypy.types import (
-    Type, Instance, CallableType, TypedDictType, UnionType, NoneTyp, FunctionLike, TypeVarType,
+    Type, Instance, CallableType, TypedDictType, UnionType, NoneTyp, TypeVarType,
     AnyType, TypeList, UnboundType, TypeOfAny
 )
 from mypy.messages import MessageBuilder
@@ -56,6 +61,9 @@ def named_generic_type(self, name: str, args: List[Type]) -> Instance:
 class SemanticAnalyzerPluginInterface:
     """Interface for accessing semantic analyzer functionality in plugins."""
 
+    options = None  # type: Options
+    msg = None  # type: MessageBuilder
+
     @abstractmethod
     def named_type(self, qualified_name: str, args: Optional[List[Type]] = None) -> Instance:
         raise NotImplementedError
@@ -69,6 +77,22 @@ def fail(self, msg: str, ctx: Context, serious: bool = False, *,
              blocker: bool = False) -> None:
         raise NotImplementedError
 
+    @abstractmethod
+    def anal_type(self, t: Type, *,
+                  tvar_scope: Optional[TypeVarScope] = None,
+                  allow_tuple_literal: bool = False,
+                  aliasing: bool = False,
+                  third_pass: bool = False) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def class_type(self, info: TypeInfo) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def lookup_fully_qualified(self, name: str) -> SymbolTableNode:
+        raise NotImplementedError
+
 
 # A context for a function hook that infers the return type of a function with
 # a special signature.
@@ -262,6 +286,17 @@ def get_method_hook(self, fullname: str
             return int_pow_callback
         return None
 
+    def get_class_decorator_hook(self, fullname: str
+                                 ) -> Optional[Callable[[ClassDefContext], None]]:
+        if fullname in mypy.plugins.attrs.attr_class_makers:
+            return mypy.plugins.attrs.attr_class_maker_callback
+        elif fullname in mypy.plugins.attrs.attr_dataclass_makers:
+            return partial(
+                mypy.plugins.attrs.attr_class_maker_callback,
+                auto_attribs_default=True
+            )
+        return None
+
 
 def open_callback(ctx: FunctionContext) -> Type:
     """Infer a better return type for 'open'.