Fixed mypy type errors in MLIR Python type stubs

[superbobry]

Summary

This commit fixes or disables all errors reported by

python3 -m mypy -p mlir --show-error-codes

Note that unhashable types cannot be currently expressed in a way compatible
with typeshed. See https://github.com/python/typeshed/issues/6243 for details.

[stellaraccident]

Can you please revert the init file. Having the _mlir_libs directory be a namespace package is an explicit decision that is load bearing for certain integrations, iirc.

Thanks for type annotation fixes!

mlir/python/mlir/_mlir_libs/__init__.py

 # Licensed under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-from typing import Sequence
+from typing import Any, Sequence
 
 import os
 
 _this_dir = os.path.dirname(__file__)
 
 
+# These submodules have no type stubs and are thus opaque to the type checker.
+_mlirConversions: Any
+_mlirTransforms: Any
+_mlirAllPassesRegistration: Any
+
+
 def get_lib_dirs() -> Sequence[str]:
   """Gets the lib directory for linking to shared libraries.
 
   On some platforms, the package may need to be built specially to export
   development libraries.
   """
   return [_this_dir]
 
 
 def get_include_dirs() -> Sequence[str]:
   """Gets the include directory for compiling against exported C libraries.
 
   Depending on how the package was build, development C libraries may or may
   not be present.
   """
   return [os.path.join(_this_dir, "include")]

mlir/python/mlir/_mlir_libs/_mlir/ir.pyi

 # Originally imported via:
 #   stubgen {...} -m mlir._mlir_libs._mlir.ir
 # Local modifications:
 #   * Rewrite references to 'mlir.ir.' to local types
 #   * Add __all__ with the following incantation:
 #       egrep '^class ' ir.pyi | awk -F ' |:|\\(' '{print "    \"" $2 "\","}'
 #   * Local edits to signatures and types that MyPy did not auto detect (or
 #     detected incorrectly).
 
-from typing import Any, Callable, ClassVar, Dict, List, Optional, Sequence, Tuple
+from typing import (
+    Any, Callable, ClassVar, Dict, List, Optional, Sequence, Tuple,
+    Type as _Type, TypeVar
+)
 
 from typing import overload
 
 __all__ = [
     "AffineAddExpr",
     "AffineBinaryExpr",
     "AffineCeilDivExpr",
     "AffineConstantExpr",
class _OperationBase:
     def operands(self) -> OpOperandList: ...
     @property
     def regions(self) -> RegionSequence: ...
     @property
     def result(self) -> OpResult: ...
     @property
     def results(self) -> OpResultList: ...
 
+_TOperation = TypeVar("_TOperation", bound=_OperationBase)
+
 # TODO: Auto-generated. Audit and fix.
 class AffineExpr:
     def __init__(self, *args, **kwargs) -> None: ...
     def _CAPICreate(self) -> AffineExpr: ...
     def compose(self, arg0) -> AffineExpr: ...
     def dump(self) -> None: ...
     def get_add(self, *args, **kwargs) -> Any: ...
     def get_ceil_div(self, *args, **kwargs) -> Any: ...

 class BF16Type(Type):
     def __init__(self, cast_from_type: Type) -> None: ...
     @staticmethod
     def get(*args, **kwargs) -> BF16Type: ...
     @staticmethod
     def isinstance(arg: Any) -> bool: ...
 
 class Block:
-    __hash__: ClassVar[None] = ...
+    __hash__: ClassVar[None] = ...  # type: ignore
     def append(self, operation: _OperationBase) -> None: ...
     def create_after(self, *args: Type) -> Block: ...
     @staticmethod
     def create_at_start(parent: Region, arg_types: List[Type]) -> Block: ...
     def create_before(self, *args: Type) -> Block: ...
     @overload
     def __eq__(self, arg0: Block) -> bool: ...
     @overload

 
 class BlockArgument(Value):
     @staticmethod
     def isinstance(arg: Any) -> bool: ...
     def set_type(self, type: Type) -> None: ...
     @property
     def arg_number(self) -> int: ...
     @property
-    def owner(self) -> Block: ...
+    def owner(self) -> Block: ...  # type: ignore[override]
 
 class BlockArgumentList:
     def __add__(self, arg0: BlockArgumentList) -> List[BlockArgument]: ...
     @overload
     def __getitem__(self, arg0: int) -> BlockArgument: ...
     @overload
     def __getitem__(self, arg0: slice) -> BlockArgumentList: ...
     def __len__(self) -> int: ...
class Context:
     def _CAPICreate(self) -> object: ...
     def _get_context_again(self) -> Context: ...
     @staticmethod
     def _get_live_count() -> int: ...
     def _get_live_module_count(self) -> int: ...
     def _get_live_operation_count(self) -> int: ...
     def attach_diagnostic_handler(self, callback: Callable[[Diagnostic], bool]) -> DiagnosticHandler: ...
     def enable_multithreading(self, enable: bool) -> None: ...
-    def get_dialect_descriptor(dialect_name: str) -> DialectDescriptor: ...
+    def get_dialect_descriptor(self, dialect_name: str) -> DialectDescriptor: ...
     def is_registered_operation(self, operation_name: str) -> bool: ...
     def __enter__(self) -> Context: ...
     def __exit__(self, arg0: object, arg1: object, arg2: object) -> None: ...
     @property
     def _CAPIPtr(self) -> object: ...
     @property
     def d(self) -> Dialects: ...
     @property
class IntegerType(Type):
     def is_signless(self) -> bool: ...
     @property
     def is_unsigned(self) -> bool: ...
     @property
     def width(self) -> int: ...
 
 class Location:
     current: ClassVar[Location] = ...  # read-only
-    __hash__: ClassVar[None] = ...
+    __hash__: ClassVar[None] = ...  # type: ignore
     def _CAPICreate(self) -> Location: ...
     @staticmethod
     def callsite(callee: Location, frames: Sequence[Location], context: Optional[Context] = None) -> Location: ...
     @staticmethod
     def file(filename: str, line: int, col: int, context: Optional[Context] = None) -> Location: ...
     @staticmethod
     def fused(locations: Sequence[Location], metadata: Optional[Attribute] = None, context: Optional[Context] = None) -> Location: ...
     @staticmethod
class MemRefType(ShapedType):
     def affine_map(self) -> AffineMap: ...
     @property
     def layout(self) -> Attribute: ...
     @property
     def memory_space(self) -> Attribute: ...
 
 class Module:
     def _CAPICreate(self) -> object: ...
+    @staticmethod
     def create(loc: Optional[Location] = None) -> Module: ...
     def dump(self) -> None: ...
     @staticmethod
     def parse(asm: str, context: Optional[Context] = None) -> Module: ...
     @property
     def _CAPIPtr(self) -> object: ...
     @property
     def body(self) -> Block: ...
class OpResultList:
     def types(self) -> List[Type]: ...
 
 class OpView(_OperationBase):
     _ODS_OPERAND_SEGMENTS: ClassVar[None] = ...
     _ODS_REGIONS: ClassVar[tuple] = ...
     _ODS_RESULT_SEGMENTS: ClassVar[None] = ...
     def __init__(self, operation: _OperationBase) -> None: ...
     @classmethod
-    def build_generic(cls, results: Optional[Sequence[Type]] = None,
+    def build_generic(
+        cls: _Type[_TOperation],
+        results: Optional[Sequence[Type]] = None,
         operands: Optional[Sequence[Value]] = None,
         attributes: Optional[Dict[str, Attribute]] = None,
         successors: Optional[Sequence[Block]] = None,
         regions: Optional[int] = None,
         loc: Optional[Location] = None,
-        ip: Optional[InsertionPoint] = None) -> _OperationBase: ...
+        ip: Optional[InsertionPoint] = None) -> _TOperation: ...
     @property
     def context(self) -> Context: ...
     @property
-    def operation(self) -> _OperationBase: ...
+    def operation(self) -> Operation: ...
 
 class Operation(_OperationBase):
     def _CAPICreate(self) -> object: ...
     @staticmethod
     def create(name: str, results: Optional[Sequence[Type]] = None,
         operands: Optional[Sequence[Value]] = None,
         attributes: Optional[Dict[str, Attribute]] = None,
         successors: Optional[Sequence[Block]] = None,
class RankedTensorType(ShapedType):
     @staticmethod
     def get(*args, **kwargs) -> RankedTensorType: ...
     @staticmethod
     def isinstance(arg: Any) -> bool: ...
     @property
     def encoding(self) -> Optional[Attribute]: ...
 
 class Region:
-    __hash__: ClassVar[None] = ...
+    __hash__: ClassVar[None] = ...  # type: ignore
     @overload
     def __eq__(self, arg0: Region) -> bool: ...
     @overload
     def __eq__(self, arg0: object) -> bool: ...
     def __iter__(self) -> BlockIterator: ...
     @property
     def blocks(self) -> BlockList: ...
     @property