code: def _diff_signatures(self, type_):
          
          missing = []
          mistyped = {}
          mismatched = {}
          for name, iface_sig in self._signatures.items():
              try:
                  # Don't invoke the descriptor protocol here so that we get
                  # staticmethod/classmethod/property objects instead of the
                  # functions they wrap.
                  f = static_get_type_attr(type_, name)
              except AttributeError:
                  missing.append(name)
                  continue
  
              impl_sig = TypedSignature(f)
  
              if not issubclass(impl_sig.type, iface_sig.type):
                  mistyped[name] = impl_sig.type
  
              if not compatible(impl_sig.signature, iface_sig.signature):
                  mismatched[name] = impl_sig
  
          return missing, mistyped, mismatched
docs: Diff our method signatures against the methods provided by type_.
  
          Parameters
          ----------
          type_ : type
             The type to check.
  
          Returns
          -------
          missing, mistyped, mismatched : list[str], dict[str -> type], dict[str -> signature]  # noqa
              ``missing`` is a list of missing interface names.
              ``mistyped`` is a list mapping names to incorrect types.
              ``mismatched`` is a dict mapping names to incorrect signatures.