Support compiling the plugin infrastructure with mypyc (#5582)

Author: msullivan

mypy/build.py

@@ -54,7 +54,7 @@
 from mypy.stats import dump_type_stats
 from mypy.types import Type
 from mypy.version import __version__
-from mypy.plugin import Plugin, DefaultPlugin, ChainedPlugin
+from mypy.plugin import Plugin, DefaultPlugin, ChainedPlugin, plugin_types
 from mypy.defaults import PYTHON3_VERSION_MIN
 from mypy.server.deps import get_dependencies
 from mypy.fscache import FileSystemCache
@@ -569,7 +569,7 @@ def plugin_error(message: str) -> None:
             plugin_error(
                 'Type object expected as the return value of "plugin"; got {!r} (in {})'.format(
                     plugin_type, plugin_path))
-        if not issubclass(plugin_type, Plugin):
+        if not issubclass(plugin_type, plugin_types):
             plugin_error(
                 'Return value of "plugin" must be a subclass of "mypy.plugin.Plugin" '
                 '(in {})'.format(plugin_path))

mypy/interpreted_plugin.py

@@ -0,0 +1,69 @@
+"""Hack for handling non-mypyc compiled plugins with a mypyc-compiled mypy"""
+
+from typing import Optional, Callable, Any
+from mypy.options import Options
+from mypy.types import Type, CallableType
+
+
+MYPY = False
+if MYPY:
+    import mypy.plugin
+
+
+class InterpretedPlugin:
+    """Base class of type checker plugins as exposed to external code.
+
+    This is a hack around mypyc not currently supporting interpreted subclasses
+    of compiled classes.
+    mypy.plugin will arrange for interpreted code to be find this class when it looks
+    for Plugin, and this class has a __new__ method that returns a WrapperPlugin object
+    that proxies to this interpreted version.
+    """
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> 'mypy.plugin.Plugin':
+        from mypy.plugin import WrapperPlugin
+        plugin = object.__new__(cls)  # type: ignore
+        plugin.__init__(*args, **kwargs)
+        return WrapperPlugin(plugin)
+
+    def __init__(self, options: Options) -> None:
+        self.options = options
+        self.python_version = options.python_version
+
+    def get_type_analyze_hook(self, fullname: str
+                              ) -> Optional[Callable[['mypy.plugin.AnalyzeTypeContext'], Type]]:
+        return None
+
+    def get_function_hook(self, fullname: str
+                          ) -> Optional[Callable[['mypy.plugin.FunctionContext'], Type]]:
+        return None
+
+    def get_method_signature_hook(self, fullname: str
+                                  ) -> Optional[Callable[['mypy.plugin.MethodSigContext'],
+                                                         CallableType]]:
+        return None
+
+    def get_method_hook(self, fullname: str
+                        ) -> Optional[Callable[['mypy.plugin.MethodContext'], Type]]:
+        return None
+
+    def get_attribute_hook(self, fullname: str
+                           ) -> Optional[Callable[['mypy.plugin.AttributeContext'], Type]]:
+        return None
+
+    def get_class_decorator_hook(self, fullname: str
+                                 ) -> Optional[Callable[['mypy.plugin.ClassDefContext'], None]]:
+        return None
+
+    def get_metaclass_hook(self, fullname: str
+                           ) -> Optional[Callable[['mypy.plugin.ClassDefContext'], None]]:
+        return None
+
+    def get_base_class_hook(self, fullname: str
+                            ) -> Optional[Callable[['mypy.plugin.ClassDefContext'], None]]:
+        return None
+
+    def get_customize_class_mro_hook(self, fullname: str
+                                     ) -> Optional[Callable[['mypy.plugin.ClassDefContext'],
+                                                            None]]:
+        return None

mypy/plugin.py

@@ -1,5 +1,7 @@
 """Plugin system for extending mypy."""
 
+import types
+
 from abc import abstractmethod
 from functools import partial
 from typing import Callable, List, Tuple, Optional, NamedTuple, TypeVar, Dict
@@ -16,6 +18,7 @@
 )
 from mypy.messages import MessageBuilder
 from mypy.options import Options
+import mypy.interpreted_plugin
 
 
 @trait
@@ -222,6 +225,58 @@ def get_customize_class_mro_hook(self, fullname: str
 T = TypeVar('T')
 
 
+class WrapperPlugin(Plugin):
+    """A plugin that wraps an interpreted plugin.
+
+    This is a ugly workaround the limitation that mypyc-compiled
+    classes can't be subclassed by interpreted ones, so instead we
+    create a new class for interpreted clients to inherit from and
+    dispatch to it from here.
+
+    Eventually mypyc ought to do something like this automatically.
+    """
+
+    def __init__(self, plugin: mypy.interpreted_plugin.InterpretedPlugin) -> None:
+        super().__init__(plugin.options)
+        self.plugin = plugin
+
+    def get_type_analyze_hook(self, fullname: str
+                              ) -> Optional[Callable[[AnalyzeTypeContext], Type]]:
+        return self.plugin.get_type_analyze_hook(fullname)
+
+    def get_function_hook(self, fullname: str
+                          ) -> Optional[Callable[[FunctionContext], Type]]:
+        return self.plugin.get_function_hook(fullname)
+
+    def get_method_signature_hook(self, fullname: str
+                                  ) -> Optional[Callable[[MethodSigContext], CallableType]]:
+        return self.plugin.get_method_signature_hook(fullname)
+
+    def get_method_hook(self, fullname: str
+                        ) -> Optional[Callable[[MethodContext], Type]]:
+        return self.plugin.get_method_hook(fullname)
+
+    def get_attribute_hook(self, fullname: str
+                           ) -> Optional[Callable[[AttributeContext], Type]]:
+        return self.plugin.get_attribute_hook(fullname)
+
+    def get_class_decorator_hook(self, fullname: str
+                                 ) -> Optional[Callable[[ClassDefContext], None]]:
+        return self.plugin.get_class_decorator_hook(fullname)
+
+    def get_metaclass_hook(self, fullname: str
+                           ) -> Optional[Callable[[ClassDefContext], None]]:
+        return self.plugin.get_metaclass_hook(fullname)
+
+    def get_base_class_hook(self, fullname: str
+                            ) -> Optional[Callable[[ClassDefContext], None]]:
+        return self.plugin.get_base_class_hook(fullname)
+
+    def get_customize_class_mro_hook(self, fullname: str
+                                     ) -> Optional[Callable[[ClassDefContext], None]]:
+        return self.plugin.get_customize_class_mro_hook(fullname)
+
+
 class ChainedPlugin(Plugin):
     """A plugin that represents a sequence of chained plugins.
 
@@ -444,3 +499,14 @@ def int_pow_callback(ctx: MethodContext) -> Type:
         else:
             return ctx.api.named_generic_type('builtins.float', [])
     return ctx.default_return_type
+
+
+# This is an incredibly frumious hack. If this module is compiled by mypyc,
+# set the module 'Plugin' attribute to point to InterpretedPlugin. This means
+# that anything interpreted that imports Plugin will get InterpretedPlugin
+# while anything compiled alongside this module will get the real Plugin.
+if isinstance(int_pow_callback, types.BuiltinFunctionType):
+    plugin_types = (Plugin, mypy.interpreted_plugin.InterpretedPlugin)  # type: Tuple[type, ...]
+    globals()['Plugin'] = mypy.interpreted_plugin.InterpretedPlugin
+else:
+    plugin_types = (Plugin,)

mypy/plugins/common.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Optional, Any
 
 from mypy.nodes import (
     ARG_POS, MDEF, Argument, Block, CallExpr, Expression, FuncBase,
@@ -47,11 +47,15 @@ def _get_argument(call: CallExpr, name: str) -> Optional[Expression]:
     #
     # Note: I'm not hard-coding the index so that in the future we can support other
     # attrib and class makers.
+    if not isinstance(call.callee, RefExpr):
+        return None
+
     callee_type = None
-    if (isinstance(call.callee, RefExpr)
-            and isinstance(call.callee.node, (Var, FuncBase))
-            and call.callee.node.type):
-        callee_node_type = call.callee.node.type
+    # mypyc hack to workaround mypy misunderstanding multiple inheritance (#3603)
+    callee_node = call.callee.node  # type: Any
+    if (isinstance(callee_node, (Var, FuncBase))
+            and callee_node.type):
+        callee_node_type = callee_node.type
         if isinstance(callee_node_type, Overloaded):
             # We take the last overload.
             callee_type = callee_node_type.items()[-1]