# Originally imported via:
# pybind11-stubgen --print-invalid-expressions-as-is mlir._mlir_libs._mlir.ir
# but with the following diff (in order to remove pipes from types,
# which we won't support until bumping minimum python to 3.10)
#
# --------------------- diff begins ------------------------------------
#
# diff --git a/pybind11_stubgen/printer.py b/pybind11_stubgen/printer.py
# index 1f755aa..4924927 100644
# --- a/pybind11_stubgen/printer.py
# +++ b/pybind11_stubgen/printer.py
# @@ -283,14 +283,6 @@ class Printer:
# return split[0] + "..."
#
# def print_type(self, type_: ResolvedType) -> str:
# - if (
# - str(type_.name) == "typing.Optional"
# - and type_.parameters is not None
# - and len(type_.parameters) == 1
# - ):
# - return f"{self.print_annotation(type_.parameters[0])} | None"
# - if str(type_.name) == "typing.Union" and type_.parameters is not None:
# - return " | ".join(self.print_annotation(p) for p in type_.parameters)
# if type_.parameters:
# param_str = (
# "["
#
# --------------------- diff ends ------------------------------------
#
# Local modifications:
# * Rewrite references to 'mlir.ir' to local types.
# * Drop `typing.` everywhere (top-level import instead).
# * List -> List, dict -> Dict, Tuple -> Tuple.
# * copy-paste Buffer type from typing_extensions.
# * Shuffle _OperationBase, AffineExpr, Attribute, Type, Value to the top.
# * Patch raw C++ types (like "PyAsmState") with a regex like `Py(.*)`.
# * _BaseContext -> Context, MlirType -> Type, MlirTypeID -> TypeID, MlirAttribute -> Attribute.
# * Local edits to signatures and types that pybind11-stubgen did not auto detect (or detected incorrectly).
# * Add MLIRError, _GlobalDebug, _OperationBase to __all__ by hand.
# * Fill in `Any`s where possible.
# * black formatting.
from __future__ import annotations
import abc
import collections
import io
from typing import (
Any,
Callable,
ClassVar,
Dict,
List,
Optional,
Sequence,
Tuple,
Type as _Type,
TypeVar,
Union,
)
from typing import overload
__all__ = [
"AffineAddExpr",
"AffineBinaryExpr",
"AffineCeilDivExpr",
"AffineConstantExpr",
"AffineDimExpr",
"AffineExpr",
"AffineExprList",
"AffineFloorDivExpr",
"AffineMap",
"AffineMapAttr",
"AffineModExpr",
"AffineMulExpr",
"AffineSymbolExpr",
"ArrayAttr",
"ArrayAttributeIterator",
"AsmState",
"AttrBuilder",
"Attribute",
"BF16Type",
"Block",
"BlockArgument",
"BlockArgumentList",
"BlockIterator",
"BlockList",
"BoolAttr",
"ComplexType",
"Context",
"DenseBoolArrayAttr",
"DenseBoolArrayIterator",
"DenseElementsAttr",
"DenseF32ArrayAttr",
"DenseF32ArrayIterator",
"DenseF64ArrayAttr",
"DenseF64ArrayIterator",
"DenseFPElementsAttr",
"DenseI16ArrayAttr",
"DenseI16ArrayIterator",
"DenseI32ArrayAttr",
"DenseI32ArrayIterator",
"DenseI64ArrayAttr",
"DenseI64ArrayIterator",
"DenseI8ArrayAttr",
"DenseI8ArrayIterator",
"DenseIntElementsAttr",
"DenseResourceElementsAttr",
"Diagnostic",
"DiagnosticHandler",
"DiagnosticInfo",
"DiagnosticSeverity",
"Dialect",
"DialectDescriptor",
"DialectRegistry",
"Dialects",
"DictAttr",
"F16Type",
"F32Type",
"F64Type",
"FlatSymbolRefAttr",
"Float8E3M4Type",
"Float8E4M3B11FNUZType",
"Float8E4M3FNType",
"Float8E4M3FNUZType",
"Float8E4M3Type",
"Float8E5M2FNUZType",
"Float8E5M2Type",
"FloatAttr",
"FloatTF32Type",
"FloatType",
"FunctionType",
"IndexType",
"InferShapedTypeOpInterface",
"InferTypeOpInterface",
"InsertionPoint",
"IntegerAttr",
"IntegerSet",
"IntegerSetConstraint",
"IntegerSetConstraintList",
"IntegerType",
"Location",
"MemRefType",
"Module",
"NamedAttribute",
"NoneType",
"OpAttributeMap",
"OpOperand",
"OpOperandIterator",
"OpOperandList",
"OpResult",
"OpResultList",
"OpSuccessors",
"OpView",
"OpaqueAttr",
"OpaqueType",
"Operation",
"OperationIterator",
"OperationList",
"RankedTensorType",
"Region",
"RegionIterator",
"RegionSequence",
"ShapedType",
"ShapedTypeComponents",
"StridedLayoutAttr",
"StringAttr",
"SymbolRefAttr",
"SymbolTable",
"TupleType",
"Type",
"TypeAttr",
"TypeID",
"UnitAttr",
"UnrankedMemRefType",
"UnrankedTensorType",
"Value",
"VectorType",
"_GlobalDebug",
"_OperationBase",
]
if hasattr(collections.abc, "Buffer"):
Buffer = collections.abc.Buffer
else:
class Buffer(abc.ABC):
pass
class _OperationBase:
@overload
def __eq__(self, arg0: _OperationBase) -> bool: ...
@overload
def __eq__(self, arg0: _OperationBase) -> bool: ...
def __hash__(self) -> int: ...
def __str__(self) -> str:
"""
Returns the assembly form of the operation.
"""
def clone(self, ip: InsertionPoint = None) -> OpView: ...
def detach_from_parent(self) -> OpView:
"""
Detaches the operation from its parent block.
"""
def erase(self) -> None: ...
def get_asm(
self,
binary: bool = False,
large_elements_limit: Optional[int] = None,
enable_debug_info: bool = False,
pretty_debug_info: bool = False,
print_generic_op_form: bool = False,
use_local_scope: bool = False,
assume_verified: bool = False,
skip_regions: bool = False,
) -> Union[io.BytesIO, io.StringIO]:
"""
Gets the assembly form of the operation with all options available.
Args:
binary: Whether to return a bytes (True) or str (False) object. Defaults to
False.
... others ...: See the print() method for common keyword arguments for
configuring the printout.
Returns:
Either a bytes or str object, depending on the setting of the 'binary'
argument.
"""
def move_after(self, other: _OperationBase) -> None:
"""
Puts self immediately after the other operation in its parent block.
"""
def move_before(self, other: _OperationBase) -> None:
"""
Puts self immediately before the other operation in its parent block.
"""
@overload
def print(
self,
state: AsmState,
file: Optional[Any] = None,
binary: bool = False,
) -> None:
"""
Prints the assembly form of the operation to a file like object.
Args:
file: The file like object to write to. Defaults to sys.stdout.
binary: Whether to write bytes (True) or str (False). Defaults to False.
state: AsmState capturing the operation numbering and flags.
"""
@overload
def print(
self,
large_elements_limit: Optional[int] = None,
enable_debug_info: bool = False,
pretty_debug_info: bool = False,
print_generic_op_form: bool = False,
use_local_scope: bool = False,
assume_verified: bool = False,
file: Optional[Any] = None,
binary: bool = False,
skip_regions: bool = False,
) -> None:
"""
Prints the assembly form of the operation to a file like object.
Args:
file: The file like object to write to. Defaults to sys.stdout.
binary: Whether to write bytes (True) or str (False). Defaults to False.
large_elements_limit: Whether to elide elements attributes above this
number of elements. Defaults to None (no limit).
enable_debug_info: Whether to print debug/location information. Defaults
to False.
pretty_debug_info: Whether to format debug information for easier reading
by a human (warning: the result is unparseable).
print_generic_op_form: Whether to print the generic assembly forms of all
ops. Defaults to False.
use_local_Scope: Whether to print in a way that is more optimized for
multi-threaded access but may not be consistent with how the overall
module prints.
assume_verified: By default, if not printing generic form, the verifier
will be run and if it fails, generic form will be printed with a comment
about failed verification. While a reasonable default for interactive use,
for systematic use, it is often better for the caller to verify explicitly
and report failures in a more robust fashion. Set this to True if doing this
in order to avoid running a redundant verification. If the IR is actually
invalid, behavior is undefined.
skip_regions: Whether to skip printing regions. Defaults to False.
"""
def verify(self) -> bool:
"""
Verify the operation. Raises MLIRError if verification fails, and returns true otherwise.
"""
def write_bytecode(self, file: Any, desired_version: Optional[int] = None) -> None:
"""
Write the bytecode form of the operation to a file like object.
Args:
file: The file like object to write to.
desired_version: The version of bytecode to emit.
Returns:
The bytecode writer status.
"""
@property
def _CAPIPtr(self) -> object: ...
@property
def attributes(self) -> OpAttributeMap: ...
@property
def context(self) -> Context:
"""
Context that owns the Operation
"""
@property
def location(self) -> Location:
"""
Returns the source location the operation was defined or derived from.
"""
@property
def name(self) -> str: ...
@property
def operands(self) -> OpOperandList: ...
@property
def parent(self) -> Optional[_OperationBase]: ...
@property
def regions(self) -> RegionSequence: ...
@property
def result(self) -> OpResult:
"""
Shortcut to get an op result if it has only one (throws an error otherwise).
"""
@property
def results(self) -> OpResultList:
"""
Returns the List of Operation results.
"""
_TOperation = TypeVar("_TOperation", bound=_OperationBase)
class AffineExpr:
@staticmethod
@overload
def get_add(arg0: AffineExpr, arg1: AffineExpr) -> AffineAddExpr:
"""
Gets an affine expression containing a sum of two expressions.
"""
@staticmethod
@overload
def get_add(arg0: int, arg1: AffineExpr) -> AffineAddExpr:
"""
Gets an affine expression containing a sum of a constant and another expression.
"""
@staticmethod
@overload
def get_add(arg0: AffineExpr, arg1: int) -> AffineAddExpr:
"""
Gets an affine expression containing a sum of an expression and a constant.
"""
@staticmethod
@overload
def get_ceil_div(arg0: AffineExpr, arg1: AffineExpr) -> AffineCeilDivExpr:
"""
Gets an affine expression containing the rounded-up result of dividing one expression by another.
"""
@staticmethod
@overload
def get_ceil_div(arg0: int, arg1: AffineExpr) -> AffineCeilDivExpr:
"""
Gets a semi-affine expression containing the rounded-up result of dividing a constant by an expression.
"""
@staticmethod
@overload
def get_ceil_div(arg0: AffineExpr, arg1: int) -> AffineCeilDivExpr:
"""
Gets an affine expression containing the rounded-up result of dividing an expression by a constant.
"""
@staticmethod
def get_constant(
value: int, context: Optional[Context] = None
) -> AffineConstantExpr:
"""
Gets a constant affine expression with the given value.
"""
@staticmethod
def get_dim(position: int, context: Optional[Context] = None) -> AffineDimExpr:
"""
Gets an affine expression of a dimension at the given position.
"""
@staticmethod
@overload
def get_floor_div(arg0: AffineExpr, arg1: AffineExpr) -> AffineFloorDivExpr:
"""
Gets an affine expression containing the rounded-down result of dividing one expression by another.
"""
@staticmethod
@overload
def get_floor_div(arg0: int, arg1: AffineExpr) -> AffineFloorDivExpr:
"""
Gets a semi-affine expression containing the rounded-down result of dividing a constant by an expression.
"""
@staticmethod
@overload
def get_floor_div(arg0: AffineExpr, arg1: int) -> AffineFloorDivExpr:
"""
Gets an affine expression containing the rounded-down result of dividing an expression by a constant.
"""
@staticmethod
@overload
def get_mod(arg0: AffineExpr, arg1: AffineExpr) -> AffineModExpr:
"""
Gets an affine expression containing the modulo of dividing one expression by another.
"""
@staticmethod
@overload
def get_mod(arg0: int, arg1: AffineExpr) -> AffineModExpr:
"""
Gets a semi-affine expression containing the modulo of dividing a constant by an expression.
"""
@staticmethod
@overload
def get_mod(arg0: AffineExpr, arg1: int) -> AffineModExpr:
"""
Gets an affine expression containing the module of dividingan expression by a constant.
"""
@staticmethod
@overload
def get_mul(arg0: AffineExpr, arg1: AffineExpr) -> AffineMulExpr:
"""
Gets an affine expression containing a product of two expressions.
"""
@staticmethod
@overload
def get_mul(arg0: int, arg1: AffineExpr) -> AffineMulExpr:
"""
Gets an affine expression containing a product of a constant and another expression.
"""
@staticmethod
@overload
def get_mul(arg0: AffineExpr, arg1: int) -> AffineMulExpr:
"""
Gets an affine expression containing a product of an expression and a constant.
"""
@staticmethod
def get_symbol(
position: int, context: Optional[Context] = None
) -> AffineSymbolExpr:
"""
Gets an affine expression of a symbol at the given position.
"""
def _CAPICreate(self) -> AffineExpr: ...
@overload
def __add__(self, arg0: AffineExpr) -> AffineAddExpr: ...
@overload
def __add__(self, arg0: int) -> AffineAddExpr: ...
@overload
def __eq__(self, arg0: AffineExpr) -> bool: ...
@overload
def __eq__(self, arg0: Any) -> bool: ...
def __hash__(self) -> int: ...
@overload
def __mod__(self, arg0: AffineExpr) -> AffineModExpr: ...
@overload
def __mod__(self, arg0: int) -> AffineModExpr: ...
@overload
def __mul__(self, arg0: AffineExpr) -> AffineMulExpr: ...
@overload
def __mul__(self, arg0: int) -> AffineMulExpr: ...
def __radd__(self, arg0: int) -> AffineAddExpr: ...
def __rmod__(self, arg0: int) -> AffineModExpr: ...
def __rmul__(self, arg0: int) -> AffineMulExpr: ...
def __rsub__(self, arg0: int) -> AffineAddExpr: ...
@overload
def __sub__(self, arg0: AffineExpr) -> AffineAddExpr: ...
@overload
def __sub__(self, arg0: int) -> AffineAddExpr: ...
def compose(self, arg0: AffineMap) -> AffineExpr: ...
def dump(self) -> None:
"""
Dumps a debug representation of the object to stderr.
"""
@property
def _CAPIPtr(self) -> object: ...
@property
def context(self) -> Context: ...
class Attribute:
@staticmethod
def parse(asm: str | bytes, context: Optional[Context] = None) -> Attribute:
"""
Parses an attribute from an assembly form. Raises an MLIRError on failure.
"""
def _CAPICreate(self) -> Attribute: ...
@overload
def __eq__(self, arg0: Attribute) -> bool: ...
@overload
def __eq__(self, arg0: object) -> bool: ...
def __hash__(self) -> int: ...
def __init__(self, cast_from_type: Attribute) -> None:
"""
Casts the passed attribute to the generic Attribute
"""
def __str__(self) -> str:
"""
Returns the assembly form of the Attribute.
"""
def dump(self) -> None:
"""
Dumps a debug representation of the object to stderr.
"""
def get_named(self, arg0: str) -> NamedAttribute:
"""
Binds a name to the attribute
"""
def maybe_downcast(self) -> Any: ...
@property
def _CAPIPtr(self) -> object: ...
@property
def context(self) -> Context:
"""
Context that owns the Attribute
"""
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class Type:
@staticmethod
def parse(asm: str | bytes, context: Optional[Context] = None) -> Type:
"""
Parses the assembly form of a type.
Returns a Type object or raises an MLIRError if the type cannot be parsed.
See also: https://mlir.llvm.org/docs/LangRef/#type-system
"""
def _CAPICreate(self) -> Type: ...
@overload
def __eq__(self, arg0: Type) -> bool: ...
@overload
def __eq__(self, arg0: object) -> bool: ...
def __hash__(self) -> int: ...
def __init__(self, cast_from_type: Type) -> None:
"""
Casts the passed type to the generic Type
"""
def __str__(self) -> str:
"""
Returns the assembly form of the type.
"""
def dump(self) -> None:
"""
Dumps a debug representation of the object to stderr.
"""
def maybe_downcast(self) -> Any: ...
@property
def _CAPIPtr(self) -> object: ...
@property
def context(self) -> Context:
"""
Context that owns the Type
"""
@property
def typeid(self) -> TypeID: ...
class Value:
def _CAPICreate(self) -> Value: ...
@overload
def __eq__(self, arg0: Value) -> bool: ...
@overload
def __eq__(self, arg0: object) -> bool: ...
def __hash__(self) -> int: ...
def __init__(self, value: Value) -> None: ...
def __str__(self) -> str:
"""
Returns the string form of the value.
If the value is a block argument, this is the assembly form of its type and the
position in the argument List. If the value is an operation result, this is
equivalent to printing the operation that produced it.
"""
def dump(self) -> None:
"""
Dumps a debug representation of the object to stderr.
"""
@overload
def get_name(self, use_local_scope: bool = False) -> str: ...
@overload
def get_name(self, state: AsmState) -> str:
"""
Returns the string form of value as an operand (i.e., the ValueID).
"""
def maybe_downcast(self) -> Any: ...
def replace_all_uses_with(self, arg0: Value) -> None:
"""
Replace all uses of value with the new value, updating anything in
the IR that uses 'self' to use the other value instead.
"""
def set_type(self, type: Type) -> None: ...
@property
def _CAPIPtr(self) -> object: ...
@property
def context(self) -> Context:
"""
Context in which the value lives.
"""
@property
def owner(self) -> _OperationBase: ...
@property
def type(self) -> Type: ...
@property
def uses(self) -> OpOperandIterator: ...
class AffineAddExpr(AffineBinaryExpr):
@staticmethod
def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineAddExpr: ...
@staticmethod
def isinstance(other: AffineExpr) -> bool: ...
def __init__(self, expr: AffineExpr) -> None: ...
class AffineBinaryExpr(AffineExpr):
@staticmethod
def isinstance(other: AffineExpr) -> bool: ...
def __init__(self, expr: AffineExpr) -> None: ...
@property
def lhs(self) -> AffineExpr: ...
@property
def rhs(self) -> AffineExpr: ...
class AffineCeilDivExpr(AffineBinaryExpr):
@staticmethod
def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineCeilDivExpr: ...
@staticmethod
def isinstance(other: AffineExpr) -> bool: ...
def __init__(self, expr: AffineExpr) -> None: ...
class AffineConstantExpr(AffineExpr):
@staticmethod
def get(value: int, context: Optional[Context] = None) -> AffineConstantExpr: ...
@staticmethod
def isinstance(other: AffineExpr) -> bool: ...
def __init__(self, expr: AffineExpr) -> None: ...
@property
def value(self) -> int: ...
class AffineDimExpr(AffineExpr):
@staticmethod
def get(position: int, context: Optional[Context] = None) -> AffineDimExpr: ...
@staticmethod
def isinstance(other: AffineExpr) -> bool: ...
def __init__(self, expr: AffineExpr) -> None: ...
@property
def position(self) -> int: ...
class AffineExprList:
def __add__(self, arg0: AffineExprList) -> List[AffineExpr]: ...
class AffineFloorDivExpr(AffineBinaryExpr):
@staticmethod
def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineFloorDivExpr: ...
@staticmethod
def isinstance(other: AffineExpr) -> bool: ...
def __init__(self, expr: AffineExpr) -> None: ...
class AffineMap:
@staticmethod
def compress_unused_symbols(
arg0: List, arg1: Optional[Context]
) -> List[AffineMap]: ...
@staticmethod
def get(
dim_count: int,
symbol_count: int,
exprs: List,
context: Optional[Context] = None,
) -> AffineMap:
"""
Gets a map with the given expressions as results.
"""
@staticmethod
def get_constant(value: int, context: Optional[Context] = None) -> AffineMap:
"""
Gets an affine map with a single constant result
"""
@staticmethod
def get_empty(context: Optional[Context] = None) -> AffineMap:
"""
Gets an empty affine map.
"""
@staticmethod
def get_identity(n_dims: int, context: Optional[Context] = None) -> AffineMap:
"""
Gets an identity map with the given number of dimensions.
"""
@staticmethod
def get_minor_identity(
n_dims: int, n_results: int, context: Optional[Context] = None
) -> AffineMap:
"""
Gets a minor identity map with the given number of dimensions and results.
"""
@staticmethod
def get_permutation(
permutation: List[int], context: Optional[Context] = None
) -> AffineMap:
"""
Gets an affine map that permutes its inputs.
"""
def _CAPICreate(self) -> AffineMap: ...
@overload
def __eq__(self, arg0: AffineMap) -> bool: ...
@overload
def __eq__(self, arg0: object) -> bool: ...
def __hash__(self) -> int: ...
def dump(self) -> None:
"""
Dumps a debug representation of the object to stderr.
"""
def get_major_submap(self, n_results: int) -> AffineMap: ...
def get_minor_submap(self, n_results: int) -> AffineMap: ...
def get_submap(self, result_positions: List[int]) -> AffineMap: ...
def replace(
self,
expr: AffineExpr,
replacement: AffineExpr,
n_result_dims: int,
n_result_syms: int,
) -> AffineMap: ...
@property
def _CAPIPtr(self) -> object: ...
@property
def context(self) -> Context:
"""
Context that owns the Affine Map
"""
@property
def is_permutation(self) -> bool: ...
@property
def is_projected_permutation(self) -> bool: ...
@property
def n_dims(self) -> int: ...
@property
def n_inputs(self) -> int: ...
@property
def n_symbols(self) -> int: ...
@property
def results(self) -> "AffineMapExprList": ...
class AffineMapAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(affine_map: AffineMap) -> AffineMapAttr:
"""
Gets an attribute wrapping an AffineMap.
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class AffineModExpr(AffineBinaryExpr):
@staticmethod
def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineModExpr: ...
@staticmethod
def isinstance(other: AffineExpr) -> bool: ...
def __init__(self, expr: AffineExpr) -> None: ...
class AffineMulExpr(AffineBinaryExpr):
@staticmethod
def get(arg0: AffineExpr, arg1: AffineExpr) -> AffineMulExpr: ...
@staticmethod
def isinstance(other: AffineExpr) -> bool: ...
def __init__(self, expr: AffineExpr) -> None: ...
class AffineSymbolExpr(AffineExpr):
@staticmethod
def get(position: int, context: Optional[Context] = None) -> AffineSymbolExpr: ...
@staticmethod
def isinstance(other: AffineExpr) -> bool: ...
def __init__(self, expr: AffineExpr) -> None: ...
@property
def position(self) -> int: ...
class ArrayAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(attributes: List, context: Optional[Context] = None) -> ArrayAttr:
"""
Gets a uniqued Array attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __add__(self, arg0: List) -> ArrayAttr: ...
def __getitem__(self, arg0: int) -> Attribute: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __iter__(
self,
) -> ArrayAttributeIterator: ...
def __len__(self) -> int: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class ArrayAttributeIterator:
def __iter__(self) -> ArrayAttributeIterator: ...
def __next__(self) -> Attribute: ...
class AsmState:
@overload
def __init__(self, value: Value, use_local_scope: bool = False) -> None: ...
@overload
def __init__(self, op: _OperationBase, use_local_scope: bool = False) -> None: ...
class AttrBuilder:
@staticmethod
def contains(arg0: str) -> bool: ...
@staticmethod
def get(arg0: str) -> Callable: ...
@staticmethod
def insert(
attribute_kind: str, attr_builder: Callable, replace: bool = False
) -> None:
"""
Register an attribute builder for building MLIR attributes from python values.
"""
class BF16Type(Type):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> BF16Type:
"""
Create a bf16 type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class Block:
@staticmethod
def create_at_start(
parent: Region,
arg_types: List[Type],
arg_locs: Optional[Sequence] = None,
) -> Block:
"""
Creates and returns a new Block at the beginning of the given region (with given argument types and locations).
"""
@overload
def __eq__(self, arg0: Block) -> bool: ...
@overload
def __eq__(self, arg0: Any) -> bool: ...
def __hash__(self) -> int: ...
def __iter__(self) -> OperationIterator:
"""
Iterates over operations in the block.
"""
def __str__(self) -> str:
"""
Returns the assembly form of the block.
"""
def append(self, operation: _OperationBase) -> None:
"""
Appends an operation to this block. If the operation is currently in another block, it will be moved.
"""
def append_to(self, arg0: Region) -> None:
"""
Append this block to a region, transferring ownership if necessary
"""
def create_after(self, *args, arg_locs: Optional[Sequence] = None) -> Block:
"""
Creates and returns a new Block after this block (with given argument types and locations).
"""
def create_before(self, *args, arg_locs: Optional[Sequence] = None) -> Block:
"""
Creates and returns a new Block before this block (with given argument types and locations).
"""
@property
def _CAPIPtr(self) -> object: ...
@property
def arguments(self) -> BlockArgumentList:
"""
Returns a List of block arguments.
"""
@property
def operations(self) -> OperationList:
"""
Returns a forward-optimized sequence of operations.
"""
@property
def owner(self) -> OpView:
"""
Returns the owning operation of this block.
"""
@property
def region(self) -> Region:
"""
Returns the owning region of this block.
"""
class BlockArgument(Value):
@staticmethod
def isinstance(other_value: Value) -> bool: ...
def __init__(self, value: Value) -> None: ...
def maybe_downcast(self) -> Any: ...
def set_type(self, type: Type) -> None: ...
@property
def arg_number(self) -> int: ...
@property
def owner(self) -> Block: ...
class BlockArgumentList:
@overload
def __getitem__(self, arg0: int) -> BlockArgument: ...
@overload
def __getitem__(self, arg0: slice) -> BlockArgumentList: ...
def __len__(self) -> int: ...
def __add__(self, arg0: BlockArgumentList) -> List[BlockArgument]: ...
@property
def types(self) -> List[Type]: ...
class BlockIterator:
def __iter__(self) -> BlockIterator: ...
def __next__(self) -> Block: ...
class BlockList:
def __getitem__(self, arg0: int) -> Block: ...
def __iter__(self) -> BlockIterator: ...
def __len__(self) -> int: ...
def append(self, *args, arg_locs: Optional[Sequence] = None) -> Block:
"""
Appends a new block, with argument types as positional args.
Returns:
The created block.
"""
class BoolAttr(Attribute):
@staticmethod
def get(value: bool, context: Optional[Context] = None) -> BoolAttr:
"""
Gets an uniqued bool attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __bool__(self: Attribute) -> bool:
"""
Converts the value of the bool attribute to a Python bool
"""
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
@property
def value(self) -> bool:
"""
Returns the value of the bool attribute
"""
class ComplexType(Type):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(arg0: Type) -> ComplexType:
"""
Create a complex type
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def element_type(self) -> Type:
"""
Returns element type.
"""
@property
def typeid(self) -> TypeID: ...
class Context:
current: ClassVar[Context] = ... # read-only
allow_unregistered_dialects: bool
@staticmethod
def _get_live_count() -> int: ...
def _CAPICreate(self) -> object: ...
def __enter__(self) -> Context: ...
def __exit__(self, arg0: Any, arg1: Any, arg2: Any) -> None: ...
def __init__(self) -> None: ...
def _clear_live_operations(self) -> int: ...
def _get_context_again(self) -> Context: ...
def _get_live_module_count(self) -> int: ...
def _get_live_operation_count(self) -> int: ...
def _get_live_operation_objects(self) -> List[Operation]: ...
def append_dialect_registry(self, registry: DialectRegistry) -> None: ...
def attach_diagnostic_handler(
self, callback: Callable[[Diagnostic], bool]
) -> DiagnosticHandler:
"""
Attaches a diagnostic handler that will receive callbacks
"""
def enable_multithreading(self, enable: bool) -> None: ...
def get_dialect_descriptor(self, dialect_name: str) -> DialectDescriptor:
"""
Gets or loads a dialect by name, returning its descriptor object
"""
def is_registered_operation(self, operation_name: str) -> bool: ...
def load_all_available_dialects(self) -> None: ...
@property
def _CAPIPtr(self) -> object: ...
@property
def d(self) -> Dialects:
"""
Alias for 'dialect'
"""
@property
def dialects(self) -> Dialects:
"""
Gets a container for accessing dialects by name
"""
class DenseBoolArrayAttr(Attribute):
@staticmethod
def get(
values: Sequence[bool], context: Optional[Context] = None
) -> DenseBoolArrayAttr:
"""
Gets a uniqued dense array attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __add__(self, arg0: List) -> DenseBoolArrayAttr: ...
def __getitem__(self, arg0: int) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __iter__(
self,
) -> DenseBoolArrayIterator: ...
def __len__(self) -> int: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseBoolArrayIterator:
def __iter__(self) -> DenseBoolArrayIterator: ...
def __next__(self) -> bool: ...
class DenseElementsAttr(Attribute):
@staticmethod
def get(
array: Buffer,
signless: bool = True,
type: Optional[Type] = None,
shape: Optional[List[int]] = None,
context: Optional[Context] = None,
) -> DenseElementsAttr:
"""
Gets a DenseElementsAttr from a Python buffer or array.
When `type` is not provided, then some limited type inferencing is done based
on the buffer format. Support presently exists for 8/16/32/64 signed and
unsigned integers and float16/float32/float64. DenseElementsAttrs of these
types can also be converted back to a corresponding buffer.
For conversions outside of these types, a `type=` must be explicitly provided
and the buffer contents must be bit-castable to the MLIR internal
representation:
* Integer types (except for i1): the buffer must be byte aligned to the
next byte boundary.
* Floating point types: Must be bit-castable to the given floating point
size.
* i1 (bool): Bit packed into 8bit words where the bit pattern matches a
row major ordering. An arbitrary Numpy `bool_` array can be bit packed to
this specification with: `np.packbits(ary, axis=None, bitorder='little')`.
If a single element buffer is passed (or for i1, a single byte with value 0
or 255), then a splat will be created.
Args:
array: The array or buffer to convert.
signless: If inferring an appropriate MLIR type, use signless types for
integers (defaults True).
type: Skips inference of the MLIR element type and uses this instead. The
storage size must be consistent with the actual contents of the buffer.
shape: Overrides the shape of the buffer when constructing the MLIR
shaped type. This is needed when the physical and logical shape differ (as
for i1).
context: Explicit context, if not from context manager.
Returns:
DenseElementsAttr on success.
Raises:
ValueError: If the type of the buffer or array cannot be matched to an MLIR
type or if the buffer does not meet expectations.
"""
@staticmethod
def get_splat(shaped_type: Type, element_attr: Attribute) -> DenseElementsAttr:
"""
Gets a DenseElementsAttr where all values are the same
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __len__(self) -> int: ...
def get_splat_value(self) -> Attribute: ...
@property
def is_splat(self) -> bool: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseF32ArrayAttr(Attribute):
@staticmethod
def get(
values: Sequence[float], context: Optional[Context] = None
) -> DenseF32ArrayAttr:
"""
Gets a uniqued dense array attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __add__(self, arg0: List) -> DenseF32ArrayAttr: ...
def __getitem__(self, arg0: int) -> float: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __iter__(
self,
) -> DenseF32ArrayIterator: ...
def __len__(self) -> int: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseF32ArrayIterator:
def __iter__(self) -> DenseF32ArrayIterator: ...
def __next__(self) -> float: ...
class DenseF64ArrayAttr(Attribute):
@staticmethod
def get(
values: Sequence[float], context: Optional[Context] = None
) -> DenseF64ArrayAttr:
"""
Gets a uniqued dense array attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __add__(self, arg0: List) -> DenseF64ArrayAttr: ...
def __getitem__(self, arg0: int) -> float: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __iter__(
self,
) -> DenseF64ArrayIterator: ...
def __len__(self) -> int: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseF64ArrayIterator:
def __iter__(self) -> DenseF64ArrayIterator: ...
def __next__(self) -> float: ...
class DenseFPElementsAttr(DenseElementsAttr):
@staticmethod
def get(
array: Buffer,
signless: bool = True,
type: Optional[Type] = None,
shape: Optional[List[int]] = None,
context: Optional[Context] = None,
) -> DenseFPElementsAttr: ...
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __getitem__(self, arg0: int) -> float: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseI16ArrayAttr(Attribute):
@staticmethod
def get(values: Sequence[int], context: Optional[Context] = None) -> DenseI16ArrayAttr:
"""
Gets a uniqued dense array attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __add__(self, arg0: List) -> DenseI16ArrayAttr: ...
def __getitem__(self, arg0: int) -> int: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __iter__(
self,
) -> DenseI16ArrayIterator: ...
def __len__(self) -> int: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseI16ArrayIterator:
def __iter__(self) -> DenseI16ArrayIterator: ...
def __next__(self) -> int: ...
class DenseI32ArrayAttr(Attribute):
@staticmethod
def get(values: Sequence[int], context: Optional[Context] = None) -> DenseI32ArrayAttr:
"""
Gets a uniqued dense array attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __add__(self, arg0: List) -> DenseI32ArrayAttr: ...
def __getitem__(self, arg0: int) -> int: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __iter__(
self,
) -> DenseI32ArrayIterator: ...
def __len__(self) -> int: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseI32ArrayIterator:
def __iter__(self) -> DenseI32ArrayIterator: ...
def __next__(self) -> int: ...
class DenseI64ArrayAttr(Attribute):
@staticmethod
def get(values: Sequence[int], context: Optional[Context] = None) -> DenseI64ArrayAttr:
"""
Gets a uniqued dense array attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __add__(self, arg0: List) -> DenseI64ArrayAttr: ...
def __getitem__(self, arg0: int) -> int: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __iter__(
self,
) -> DenseI16ArrayIterator: ...
def __len__(self) -> int: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseI64ArrayIterator:
def __iter__(self) -> DenseI64ArrayIterator: ...
def __next__(self) -> int: ...
class DenseI8ArrayAttr(Attribute):
@staticmethod
def get(values: Sequence[int], context: Optional[Context] = None) -> DenseI8ArrayAttr:
"""
Gets a uniqued dense array attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __add__(self, arg0: List) -> DenseI8ArrayAttr: ...
def __getitem__(self, arg0: int) -> int: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __iter__(
self,
) -> DenseI8ArrayIterator: ...
def __len__(self) -> int: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseI8ArrayIterator:
def __iter__(self) -> DenseI8ArrayIterator: ...
def __next__(self) -> int: ...
class DenseIntElementsAttr(DenseElementsAttr):
@staticmethod
def get(
array: Buffer,
signless: bool = True,
type: Optional[Type] = None,
shape: Optional[List[int]] = None,
context: Optional[Context] = None,
) -> DenseIntElementsAttr: ...
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __getitem__(self, arg0: int) -> int: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class DenseResourceElementsAttr(Attribute):
@staticmethod
def get_from_buffer(
array: Buffer,
name: str,
type: Type,
alignment: Optional[int] = None,
is_mutable: bool = False,
context: Optional[Context] = None,
) -> DenseResourceElementsAttr:
"""
Gets a DenseResourceElementsAttr from a Python buffer or array.
This function does minimal validation or massaging of the data, and it is
up to the caller to ensure that the buffer meets the characteristics
implied by the shape.
The backing buffer and any user objects will be retained for the lifetime
of the resource blob. This is typically bounded to the context but the
resource can have a shorter lifespan depending on how it is used in
subsequent processing.
Args:
buffer: The array or buffer to convert.
name: Name to provide to the resource (may be changed upon collision).
type: The explicit ShapedType to construct the attribute with.
context: Explicit context, if not from context manager.
Returns:
DenseResourceElementsAttr on success.
Raises:
ValueError: If the type of the buffer or array cannot be matched to an MLIR
type or if the buffer does not meet expectations.
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class Diagnostic:
@property
def location(self) -> Location: ...
@property
def message(self) -> str: ...
@property
def notes(self) -> Tuple[Diagnostic]: ...
@property
def severity(self) -> DiagnosticSeverity: ...
class DiagnosticHandler:
def __enter__(self) -> DiagnosticHandler: ...
def __exit__(self, arg0: object, arg1: object, arg2: object) -> None: ...
def detach(self) -> None: ...
@property
def attached(self) -> bool: ...
@property
def had_error(self) -> bool: ...
class DiagnosticInfo:
def __init__(self, arg0: Diagnostic) -> None: ...
@property
def location(self) -> Location: ...
@property
def message(self) -> str: ...
@property
def notes(self) -> List[DiagnosticInfo]: ...
@property
def severity(self) -> DiagnosticSeverity: ...
class DiagnosticSeverity:
"""
Members:
ERROR
WARNING
NOTE
REMARK
"""
ERROR: ClassVar[DiagnosticSeverity] # value = <DiagnosticSeverity.ERROR: 0>
NOTE: ClassVar[DiagnosticSeverity] # value = <DiagnosticSeverity.NOTE: 2>
REMARK: ClassVar[DiagnosticSeverity] # value = <DiagnosticSeverity.REMARK: 3>
WARNING: ClassVar[DiagnosticSeverity] # value = <DiagnosticSeverity.WARNING: 1>
__members__: ClassVar[
Dict[str, DiagnosticSeverity]
] # value = {'ERROR': <DiagnosticSeverity.ERROR: 0>, 'WARNING': <DiagnosticSeverity.WARNING: 1>, 'NOTE': <DiagnosticSeverity.NOTE: 2>, 'REMARK': <DiagnosticSeverity.REMARK: 3>}
def __eq__(self, other: Any) -> bool: ...
def __getstate__(self) -> int: ...
def __hash__(self) -> int: ...
def __index__(self) -> int: ...
def __init__(self, value: int) -> None: ...
def __int__(self) -> int: ...
def __ne__(self, other: Any) -> bool: ...
def __setstate__(self, state: int) -> None: ...
@property
def name(self) -> str: ...
@property
def value(self) -> int: ...
class Dialect:
def __init__(self, descriptor: DialectDescriptor) -> None: ...
@property
def descriptor(self) -> DialectDescriptor: ...
class DialectDescriptor:
@property
def namespace(self) -> str: ...
class DialectRegistry:
def _CAPICreate(self) -> DialectRegistry: ...
def __init__(self) -> None: ...
@property
def _CAPIPtr(self) -> object: ...
class Dialects:
def __getattr__(self, arg0: str) -> Dialect: ...
def __getitem__(self, arg0: str) -> Dialect: ...
class DictAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(value: Dict = {}, context: Optional[Context] = None) -> DictAttr:
"""
Gets an uniqued Dict attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __contains__(self, arg0: str) -> bool: ...
@overload
def __getitem__(self, arg0: str) -> Attribute: ...
@overload
def __getitem__(self, arg0: int) -> NamedAttribute: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __len__(self) -> int: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class FloatType(Type):
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def width(self) -> int:
"""
Returns the width of the floating-point type.
"""
class F16Type(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> F16Type:
"""
Create a f16 type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class F32Type(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> F32Type:
"""
Create a f32 type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class F64Type(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> F64Type:
"""
Create a f64 type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class FlatSymbolRefAttr(Attribute):
@staticmethod
def get(value: str, context: Optional[Context] = None) -> FlatSymbolRefAttr:
"""
Gets a uniqued FlatSymbolRef attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
@property
def value(self) -> str:
"""
Returns the value of the FlatSymbolRef attribute as a string
"""
class Float8E3M4Type(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> Float8E3M4Type:
"""
Create a float8_e3m4 type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class Float8E4M3B11FNUZType(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> Float8E4M3B11FNUZType:
"""
Create a float8_e4m3b11fnuz type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class Float8E4M3FNType(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> Float8E4M3FNType:
"""
Create a float8_e4m3fn type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class Float8E4M3FNUZType(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> Float8E4M3FNUZType:
"""
Create a float8_e4m3fnuz type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class Float8E4M3Type(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> Float8E4M3Type:
"""
Create a float8_e4m3 type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class Float8E5M2FNUZType(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> Float8E5M2FNUZType:
"""
Create a float8_e5m2fnuz type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class Float8E5M2Type(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> Float8E5M2Type:
"""
Create a float8_e5m2 type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class FloatAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(type: Type, value: float, loc: Optional[Location] = None) -> FloatAttr:
"""
Gets an uniqued float point attribute associated to a type
"""
@staticmethod
def get_f32(value: float, context: Optional[Context] = None) -> FloatAttr:
"""
Gets an uniqued float point attribute associated to a f32 type
"""
@staticmethod
def get_f64(value: float, context: Optional[Context] = None) -> FloatAttr:
"""
Gets an uniqued float point attribute associated to a f64 type
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __float__(self: Attribute) -> float:
"""
Converts the value of the float attribute to a Python float
"""
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
@property
def value(self) -> float:
"""
Returns the value of the float attribute
"""
class FloatTF32Type(FloatType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> FloatTF32Type:
"""
Create a tf32 type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class FunctionType(Type):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(
inputs: List[Type], results: List[Type], context: Optional[Context] = None
) -> FunctionType:
"""
Gets a FunctionType from a List of input and result types
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def inputs(self) -> List:
"""
Returns the List of input types in the FunctionType.
"""
@property
def results(self) -> List:
"""
Returns the List of result types in the FunctionType.
"""
@property
def typeid(self) -> TypeID: ...
class IndexType(Type):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> IndexType:
"""
Create a index type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class InferShapedTypeOpInterface:
def __init__(self, object: object, context: Optional[Context] = None) -> None:
"""
Creates an interface from a given operation/opview object or from a
subclass of OpView. Raises ValueError if the operation does not implement the
interface.
"""
def inferReturnTypeComponents(
self,
operands: Optional[List] = None,
attributes: Optional[Attribute] = None,
properties=None,
regions: Optional[List[Region]] = None,
context: Optional[Context] = None,
loc: Optional[Location] = None,
) -> List[ShapedTypeComponents]:
"""
Given the arguments required to build an operation, attempts to infer
its return shaped type components. Raises ValueError on failure.
"""
@property
def operation(self) -> Operation:
"""
Returns an Operation for which the interface was constructed.
"""
@property
def opview(self) -> OpView:
"""
Returns an OpView subclass _instance_ for which the interface was
constructed
"""
class InferTypeOpInterface:
def __init__(self, object: object, context: Optional[Context] = None) -> None:
"""
Creates an interface from a given operation/opview object or from a
subclass of OpView. Raises ValueError if the operation does not implement the
interface.
"""
def inferReturnTypes(
self,
operands: Optional[List] = None,
attributes: Optional[Attribute] = None,
properties=None,
regions: Optional[List[Region]] = None,
context: Optional[Context] = None,
loc: Optional[Location] = None,
) -> List[Type]:
"""
Given the arguments required to build an operation, attempts to infer
its return types. Raises ValueError on failure.
"""
@property
def operation(self) -> Operation:
"""
Returns an Operation for which the interface was constructed.
"""
@property
def opview(self) -> OpView:
"""
Returns an OpView subclass _instance_ for which the interface was
constructed
"""
class InsertionPoint:
current: ClassVar[InsertionPoint] = ... # read-only
@staticmethod
def at_block_begin(block: Block) -> InsertionPoint:
"""
Inserts at the beginning of the block.
"""
@staticmethod
def at_block_terminator(block: Block) -> InsertionPoint:
"""
Inserts before the block terminator.
"""
def __enter__(self) -> InsertionPoint: ...
def __exit__(self, arg0: Any, arg1: Any, arg2: Any) -> None: ...
@overload
def __init__(self, block: Block) -> None:
"""
Inserts after the last operation but still inside the block.
"""
@overload
def __init__(self, beforeOperation: _OperationBase) -> None:
"""
Inserts before a referenced operation.
"""
def insert(self, operation: _OperationBase) -> None:
"""
Inserts an operation.
"""
@property
def block(self) -> Block:
"""
Returns the block that this InsertionPoint points to.
"""
@property
def ref_operation(self) -> Optional[_OperationBase]:
"""
The reference operation before which new operations are inserted, or None if the insertion point is at the end of the block
"""
class IntegerAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(type: Type, value: int) -> IntegerAttr:
"""
Gets an uniqued integer attribute associated to a type
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
def __int__(self) -> int:
"""
Converts the value of the integer attribute to a Python int
"""
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
@property
def value(self) -> int:
"""
Returns the value of the integer attribute
"""
class IntegerSet:
@staticmethod
def get(
num_dims: int,
num_symbols: int,
exprs: List,
eq_flags: List[bool],
context: Optional[Context] = None,
) -> IntegerSet: ...
@staticmethod
def get_empty(
num_dims: int, num_symbols: int, context: Optional[Context] = None
) -> IntegerSet: ...
def _CAPICreate(self) -> IntegerSet: ...
@overload
def __eq__(self, arg0: IntegerSet) -> bool: ...
@overload
def __eq__(self, arg0: object) -> bool: ...
def __hash__(self) -> int: ...
def dump(self) -> None:
"""
Dumps a debug representation of the object to stderr.
"""
def get_replaced(
self,
dim_exprs: List,
symbol_exprs: List,
num_result_dims: int,
num_result_symbols: int,
) -> IntegerSet: ...
@property
def _CAPIPtr(self) -> object: ...
@property
def constraints(self) -> IntegerSetConstraintList: ...
@property
def context(self) -> Context: ...
@property
def is_canonical_empty(self) -> bool: ...
@property
def n_dims(self) -> int: ...
@property
def n_equalities(self) -> int: ...
@property
def n_inequalities(self) -> int: ...
@property
def n_inputs(self) -> int: ...
@property
def n_symbols(self) -> int: ...
class IntegerSetConstraint:
def __init__(self, *args, **kwargs) -> None: ...
@property
def expr(self) -> AffineExpr: ...
@property
def is_eq(self) -> bool: ...
class IntegerSetConstraintList:
def __init__(self, *args, **kwargs) -> None: ...
def __add__(self, arg0: IntegerSetConstraintList) -> List[IntegerSetConstraint]: ...
@overload
def __getitem__(self, arg0: int) -> IntegerSetConstraint: ...
@overload
def __getitem__(self, arg0: slice) -> IntegerSetConstraintList: ...
def __len__(self) -> int: ...
class IntegerType(Type):
static_typeid: ClassVar[TypeID]
@staticmethod
def get_signed(width: int, context: Optional[Context] = None) -> IntegerType:
"""
Create a signed integer type
"""
@staticmethod
def get_signless(width: int, context: Optional[Context] = None) -> IntegerType:
"""
Create a signless integer type
"""
@staticmethod
def get_unsigned(width: int, context: Optional[Context] = None) -> IntegerType:
"""
Create an unsigned integer type
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def is_signed(self) -> bool:
"""
Returns whether this is a signed integer
"""
@property
def is_signless(self) -> bool:
"""
Returns whether this is a signless integer
"""
@property
def is_unsigned(self) -> bool:
"""
Returns whether this is an unsigned integer
"""
@property
def typeid(self) -> TypeID: ...
@property
def width(self) -> int:
"""
Returns the width of the integer type
"""
class Location:
current: ClassVar[Location] = ... # read-only
__hash__: ClassVar[None] = None
@staticmethod
def callsite(
callee: Location, frames: Sequence[Location], context: Optional[Context] = None
) -> Location:
"""
Gets a Location representing a caller and callsite
"""
@staticmethod
def file(
filename: str, line: int, col: int, context: Optional[Context] = None
) -> Location:
"""
Gets a Location representing a file, line and column
"""
@staticmethod
def from_attr(attribute: Attribute, context: Optional[Context] = None) -> Location:
"""
Gets a Location from a LocationAttr
"""
@staticmethod
def fused(
locations: Sequence[Location],
metadata: Optional[Attribute] = None,
context: Optional[Context] = None,
) -> Location:
"""
Gets a Location representing a fused location with optional metadata
"""
@staticmethod
def name(
name: str,
childLoc: Optional[Location] = None,
context: Optional[Context] = None,
) -> Location:
"""
Gets a Location representing a named location with optional child location
"""
@staticmethod
def unknown(context: Optional[Context] = None) -> Location:
"""
Gets a Location representing an unknown location
"""
def _CAPICreate(self) -> Location: ...
def __enter__(self) -> Location: ...
@overload
def __eq__(self, arg0: Location) -> bool: ...
@overload
def __eq__(self, arg0: Location) -> bool: ...
def __exit__(self, arg0: object, arg1: object, arg2: object) -> None: ...
def emit_error(self, message: str) -> None:
"""
Emits an error at this location
"""
@property
def _CAPIPtr(self) -> object: ...
@property
def attr(self) -> Attribute:
"""
Get the underlying LocationAttr
"""
@property
def context(self) -> Context:
"""
Context that owns the Location
"""
class MemRefType(ShapedType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(
shape: List[int],
element_type: Type,
layout: Attribute = None,
memory_space: Attribute = None,
loc: Optional[Location] = None,
) -> MemRefType:
"""
Create a memref type
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def affine_map(self) -> AffineMap:
"""
The layout of the MemRef type as an affine map.
"""
@property
def layout(self) -> Attribute:
"""
The layout of the MemRef type.
"""
@property
def memory_space(self) -> Optional[Attribute]:
"""
Returns the memory space of the given MemRef type.
"""
@property
def typeid(self) -> TypeID: ...
class Module:
@staticmethod
def create(loc: Optional[Location] = None) -> Module:
"""
Creates an empty module
"""
@staticmethod
def parse(asm: str | bytes, context: Optional[Context] = None) -> Module:
"""
Parses a module's assembly format from a string.
Returns a new MlirModule or raises an MLIRError if the parsing fails.
See also: https://mlir.llvm.org/docs/LangRef/
"""
def _CAPICreate(self) -> Any: ...
def __str__(self) -> str:
"""
Gets the assembly form of the operation with default options.
If more advanced control over the assembly formatting or I/O options is needed,
use the dedicated print or get_asm method, which supports keyword arguments to
customize behavior.
"""
def dump(self) -> None:
"""
Dumps a debug representation of the object to stderr.
"""
@property
def _CAPIPtr(self) -> object: ...
@property
def body(self) -> Block:
"""
Return the block for this module
"""
@property
def context(self) -> Context:
"""
Context that created the Module
"""
@property
def operation(self) -> Operation:
"""
Accesses the module as an operation
"""
class MLIRError(Exception):
def __init__(
self, message: str, error_diagnostics: List[DiagnosticInfo]
) -> None: ...
class NamedAttribute:
@property
def attr(self) -> Attribute:
"""
The underlying generic attribute of the NamedAttribute binding
"""
@property
def name(self) -> str:
"""
The name of the NamedAttribute binding
"""
class NoneType(Type):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> NoneType:
"""
Create a none type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class OpAttributeMap:
def __contains__(self, arg0: str) -> bool: ...
def __delitem__(self, arg0: str) -> None: ...
@overload
def __getitem__(self, arg0: str) -> Attribute: ...
@overload
def __getitem__(self, arg0: int) -> NamedAttribute: ...
def __len__(self) -> int: ...
def __setitem__(self, arg0: str, arg1: Attribute) -> None: ...
class OpOperand:
@property
def operand_number(self) -> int: ...
@property
def owner(self) -> _OperationBase: ...
class OpOperandIterator:
def __iter__(self) -> OpOperandIterator: ...
def __next__(self) -> OpOperand: ...
class OpOperandList:
def __add__(self, arg0: OpOperandList) -> List[Value]: ...
@overload
def __getitem__(self, arg0: int) -> Value: ...
@overload
def __getitem__(self, arg0: slice) -> OpOperandList: ...
def __len__(self) -> int: ...
def __setitem__(self, arg0: int, arg1: Value) -> None: ...
class OpResult(Value):
@staticmethod
def isinstance(other_value: Value) -> bool: ...
def __init__(self, value: Value) -> None: ...
@staticmethod
def isinstance(arg: Any) -> bool: ...
@property
def owner(self) -> _OperationBase: ...
@property
def result_number(self) -> int: ...
class OpResultList:
def __add__(self, arg0: OpResultList) -> List[OpResult]: ...
@overload
def __getitem__(self, arg0: int) -> OpResult: ...
@overload
def __getitem__(self, arg0: slice) -> OpResultList: ...
def __len__(self) -> int: ...
@property
def owner(self) -> _OperationBase: ...
@property
def types(self) -> List[Type]: ...
class OpSuccessors:
def __add__(self, arg0: OpSuccessors) -> List[Block]: ...
@overload
def __getitem__(self, arg0: int) -> Block: ...
@overload
def __getitem__(self, arg0: slice) -> OpSuccessors: ...
def __setitem__(self, arg0: int, arg1: Block) -> None: ...
def __len__(self) -> int: ...
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: _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,
) -> _TOperation:
"""
Builds a specific, generated OpView based on class level attributes.
"""
@classmethod
def parse(
cls: _Type[_TOperation],
source: str | bytes,
*,
source_name: str = "",
context: Optional[Context] = None,
) -> _TOperation:
"""
Parses a specific, generated OpView based on class level attributes
"""
def __init__(self, operation: _OperationBase) -> None: ...
@property
def operation(self) -> _OperationBase: ...
@property
def opview(self) -> OpView: ...
@property
def successors(self) -> OpSuccessors:
"""
Returns the List of Operation successors.
"""
class OpaqueAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(
dialect_namespace: str,
buffer: Buffer,
type: Type,
context: Optional[Context] = None,
) -> OpaqueAttr:
"""
Gets an Opaque attribute.
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def data(self) -> bytes:
"""
Returns the data for the Opaqued attributes as `bytes`
"""
@property
def dialect_namespace(self) -> str:
"""
Returns the dialect namespace for the Opaque attribute as a string
"""
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class OpaqueType(Type):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(
dialect_namespace: str, buffer: str, context: Optional[Context] = None
) -> OpaqueType:
"""
Create an unregistered (opaque) dialect type.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def data(self) -> str:
"""
Returns the data for the Opaque type as a string.
"""
@property
def dialect_namespace(self) -> str:
"""
Returns the dialect namespace for the Opaque type as a string.
"""
@property
def typeid(self) -> TypeID: ...
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,
regions: int = 0,
loc: Optional[Location] = None,
ip: Optional[InsertionPoint] = None,
infer_type: bool = False,
) -> Operation:
"""
Creates a new operation.
Args:
name: Operation name (e.g. "dialect.operation").
results: Sequence of Type representing op result types.
attributes: Dict of str:Attribute.
successors: List of Block for the operation's successors.
regions: Number of regions to create.
location: A Location object (defaults to resolve from context manager).
ip: An InsertionPoint (defaults to resolve from context manager or set to
False to disable insertion, even with an insertion point set in the
context manager).
infer_type: Whether to infer result types.
Returns:
A new "detached" Operation object. Detached operations can be added
to blocks, which causes them to become "attached."
"""
@staticmethod
def parse(
source: str | bytes, *, source_name: str = "", context: Optional[Context] = None
) -> Operation:
"""
Parses an operation. Supports both text assembly format and binary bytecode format.
"""
def _CAPICreate(self) -> object: ...
@property
def _CAPIPtr(self) -> object: ...
@property
def operation(self) -> Operation: ...
@property
def opview(self) -> OpView: ...
@property
def successors(self) -> OpSuccessors:
"""
Returns the List of Operation successors.
"""
class OperationIterator:
def __iter__(self) -> OperationIterator: ...
def __next__(self) -> OpView: ...
class OperationList:
def __getitem__(self, arg0: int) -> OpView: ...
def __iter__(self) -> OperationIterator: ...
def __len__(self) -> int: ...
class RankedTensorType(ShapedType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(
shape: List[int],
element_type: Type,
encoding: Optional[Attribute] = None,
loc: Optional[Location] = None,
) -> RankedTensorType:
"""
Create a ranked tensor type
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def encoding(self) -> Optional[Attribute]: ...
@property
def typeid(self) -> TypeID: ...
class Region:
__hash__: ClassVar[None] = None
@overload
def __eq__(self, arg0: Region) -> bool: ...
@overload
def __eq__(self, arg0: object) -> bool: ...
def __iter__(self) -> BlockIterator:
"""
Iterates over blocks in the region.
"""
@property
def blocks(self) -> BlockList:
"""
Returns a forward-optimized sequence of blocks.
"""
@property
def owner(self) -> OpView:
"""
Returns the operation owning this region.
"""
class RegionIterator:
def __iter__(self) -> RegionIterator: ...
def __next__(self) -> Region: ...
class RegionSequence:
def __getitem__(self, arg0: int) -> Region: ...
def __iter__(self) -> RegionIterator: ...
def __len__(self) -> int: ...
class ShapedType(Type):
@staticmethod
def get_dynamic_size() -> int:
"""
Returns the value used to indicate dynamic dimensions in shaped types.
"""
@staticmethod
def get_dynamic_stride_or_offset() -> int:
"""
Returns the value used to indicate dynamic strides or offsets in shaped types.
"""
@staticmethod
def is_dynamic_size(dim_size: int) -> bool:
"""
Returns whether the given dimension size indicates a dynamic dimension.
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
def get_dim_size(self, dim: int) -> int:
"""
Returns the dim-th dimension of the given ranked shaped type.
"""
def is_dynamic_dim(self, dim: int) -> bool:
"""
Returns whether the dim-th dimension of the given shaped type is dynamic.
"""
def is_dynamic_stride_or_offset(self, dim_size: int) -> bool:
"""
Returns whether the given value is used as a placeholder for dynamic strides and offsets in shaped types.
"""
@property
def element_type(self) -> Type:
"""
Returns the element type of the shaped type.
"""
@property
def has_rank(self) -> bool:
"""
Returns whether the given shaped type is ranked.
"""
@property
def has_static_shape(self) -> bool:
"""
Returns whether the given shaped type has a static shape.
"""
@property
def rank(self) -> int:
"""
Returns the rank of the given ranked shaped type.
"""
@property
def shape(self) -> List[int]:
"""
Returns the shape of the ranked shaped type as a List of integers.
"""
@property
def static_typeid(self) -> TypeID: ...
@property
def typeid(self) -> TypeID: ...
class ShapedTypeComponents:
@staticmethod
@overload
def get(element_type: Type) -> ShapedTypeComponents:
"""
Create an shaped type components object with only the element type.
"""
@staticmethod
@overload
def get(shape: List, element_type: Type) -> ShapedTypeComponents:
"""
Create a ranked shaped type components object.
"""
@staticmethod
@overload
def get(
shape: List, element_type: Type, attribute: Attribute
) -> ShapedTypeComponents:
"""
Create a ranked shaped type components object with attribute.
"""
@property
def element_type(self) -> Type:
"""
Returns the element type of the shaped type components.
"""
@property
def has_rank(self) -> bool:
"""
Returns whether the given shaped type component is ranked.
"""
@property
def rank(self) -> int:
"""
Returns the rank of the given ranked shaped type components. If the shaped type components does not have a rank, None is returned.
"""
@property
def shape(self) -> List[int]:
"""
Returns the shape of the ranked shaped type components as a List of integers. Returns none if the shaped type component does not have a rank.
"""
class StridedLayoutAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(
offset: int, strides: List[int], context: Optional[Context] = None
) -> StridedLayoutAttr:
"""
Gets a strided layout attribute.
"""
@staticmethod
def get_fully_dynamic(
rank: int, context: Optional[Context] = None
) -> StridedLayoutAttr:
"""
Gets a strided layout attribute with dynamic offset and strides of a given rank.
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def offset(self) -> int:
"""
Returns the value of the float point attribute
"""
@property
def strides(self) -> List[int]:
"""
Returns the value of the float point attribute
"""
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class StringAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(value: str | bytes, context: Optional[Context] = None) -> StringAttr:
"""
Gets a uniqued string attribute
"""
@staticmethod
def get_typed(type: Type, value: str) -> StringAttr:
"""
Gets a uniqued string attribute associated to a type
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
@property
def value(self) -> str:
"""
Returns the value of the string attribute
"""
@property
def value_bytes(self) -> bytes:
"""
Returns the value of the string attribute as `bytes`
"""
class SymbolRefAttr(Attribute):
@staticmethod
def get(symbols: List[str], context: Optional[Context] = None) -> Attribute:
"""
Gets a uniqued SymbolRef attribute from a List of symbol names
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def static_typeid(self) -> TypeID: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
@property
def value(self) -> List[str]:
"""
Returns the value of the SymbolRef attribute as a List[str]
"""
class SymbolTable:
@staticmethod
def get_symbol_name(symbol: _OperationBase) -> Attribute: ...
@staticmethod
def get_visibility(symbol: _OperationBase) -> Attribute: ...
@staticmethod
def replace_all_symbol_uses(
old_symbol: str, new_symbol: str, from_op: _OperationBase
) -> None: ...
@staticmethod
def set_symbol_name(symbol: _OperationBase, name: str) -> None: ...
@staticmethod
def set_visibility(symbol: _OperationBase, visibility: str) -> None: ...
@staticmethod
def walk_symbol_tables(
from_op: _OperationBase,
all_sym_uses_visible: bool,
callback: Callable[[_OperationBase, bool], None],
) -> None: ...
def __contains__(self, arg0: str) -> bool: ...
def __delitem__(self, arg0: str) -> None: ...
def __getitem__(self, arg0: str) -> OpView: ...
def __init__(self, arg0: _OperationBase) -> None: ...
def erase(self, operation: _OperationBase) -> None: ...
def insert(self, operation: _OperationBase) -> Attribute: ...
class TupleType(Type):
static_typeid: ClassVar[TypeID]
@staticmethod
def get_tuple(elements: List[Type], context: Optional[Context] = None) -> TupleType:
"""
Create a Tuple type
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
def get_type(self, pos: int) -> Type:
"""
Returns the pos-th type in the Tuple type.
"""
@property
def num_types(self) -> int:
"""
Returns the number of types contained in a Tuple.
"""
@property
def typeid(self) -> TypeID: ...
class TypeAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(value: Type, context: Optional[Context] = None) -> TypeAttr:
"""
Gets a uniqued Type attribute
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
@property
def value(self) -> Type: ...
class TypeID:
def _CAPICreate(self) -> TypeID: ...
@overload
def __eq__(self, arg0: TypeID) -> bool: ...
@overload
def __eq__(self, arg0: Any) -> bool: ...
def __hash__(self) -> int: ...
@property
def _CAPIPtr(self) -> object: ...
class UnitAttr(Attribute):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(context: Optional[Context] = None) -> UnitAttr:
"""
Create a Unit attribute.
"""
@staticmethod
def isinstance(other: Attribute) -> bool: ...
def __init__(self, cast_from_attr: Attribute) -> None: ...
@property
def type(self) -> Type: ...
@property
def typeid(self) -> TypeID: ...
class UnrankedMemRefType(ShapedType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(
element_type: Type, memory_space: Attribute, loc: Optional[Location] = None
) -> UnrankedMemRefType:
"""
Create a unranked memref type
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def memory_space(self) -> Optional[Attribute]:
"""
Returns the memory space of the given Unranked MemRef type.
"""
@property
def typeid(self) -> TypeID: ...
class UnrankedTensorType(ShapedType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(element_type: Type, loc: Optional[Location] = None) -> UnrankedTensorType:
"""
Create a unranked tensor type
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def typeid(self) -> TypeID: ...
class VectorType(ShapedType):
static_typeid: ClassVar[TypeID]
@staticmethod
def get(
shape: List[int],
element_type: Type,
*,
scalable: Optional[List] = None,
scalable_dims: Optional[List[int]] = None,
loc: Optional[Location] = None,
) -> VectorType:
"""
Create a vector type
"""
@staticmethod
def isinstance(other: Type) -> bool: ...
def __init__(self, cast_from_type: Type) -> None: ...
@property
def scalable(self) -> bool: ...
@property
def scalable_dims(self) -> List[bool]: ...
@property
def typeid(self) -> TypeID: ...
class _GlobalDebug:
flag: ClassVar[bool] = False
Codebase Browser
llvm