Skip to content

Function

Warning

This page is under construction. The content may be incomplete or incorrect. Submit an issue on GitHub if you need help or want to contribute.

Call krin-statement 

Call(
    callee: SSAValue,
    inputs: tuple[SSAValue, ...],
    *,
    kwargs: tuple[str, ...] = ()
)

Bases: Statement

callee kirin-argument 

callee: SSAValue = argument()

inputs kirin-argument 

inputs: tuple[SSAValue, ...] = argument()

kwargs kirin-property kw-only 

kwargs: tuple[str, ...] = attribute(
    default_factory=lambda: (), property=True
)

name class-attribute instance-attribute 

name = 'call'

result kirin-result 

result: ResultValue = result()

print_impl 

print_impl(printer: Printer) -> None
Source code in src/kirin/dialects/func/stmts.py 
81
82
def print_impl(self, printer: Printer) -> None:
    pprint_calllike(self, printer.state.ssa_id[self.callee], printer)

ConstantNone krin-statement 

ConstantNone()

Bases: Statement

A constant None value.

This is mainly used to represent the None return value of a function to match Python semantics.

name class-attribute instance-attribute 

name = 'const.none'

result kirin-result 

result: ResultValue = result(NoneType)

traits class-attribute instance-attribute 

traits = frozenset({Pure(), ConstantLike()})

FuncOpCallableInterface dataclass 

FuncOpCallableInterface()

Bases: CallableStmtInterface['Function']

get_callable_region classmethod 

get_callable_region(stmt: Function) -> Region

Returns the body of the callable region

Source code in src/kirin/dialects/func/stmts.py 
29
30
31
@classmethod
def get_callable_region(cls, stmt: "Function") -> Region:
    return stmt.body

Function krin-statement 

Function(
    *, sym_name: str, signature: Signature, body: Region
)

Bases: Statement

body kirin-region kw-only 

body: Region = region(multi=True)

name class-attribute instance-attribute 

name = 'func'

signature kirin-attribute kw-only 

signature: Signature = attribute()

sym_name kirin-property kw-only 

sym_name: str = attribute(property=True)

The symbol name of the function.

traits class-attribute instance-attribute 

traits = frozenset(
    {
        IsolatedFromAbove(),
        SymbolOpInterface(),
        HasSignature(),
        FuncOpCallableInterface(),
        SSACFGRegion(),
    }
)

print_impl 

print_impl(printer: Printer) -> None
Source code in src/kirin/dialects/func/stmts.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
def print_impl(self, printer: Printer) -> None:
    with printer.rich(style="keyword"):
        printer.print_name(self)
        printer.plain_print(" ")

    with printer.rich(style="symbol"):
        printer.plain_print(self.sym_name)

    printer.print_seq(self.signature.inputs, prefix="(", suffix=")", delim=", ")

    with printer.rich(style="comment"):
        printer.plain_print(" -> ")
        printer.print(self.signature.output)
        printer.plain_print(" ")

    printer.print(self.body)

    with printer.rich(style="comment"):
        printer.plain_print(f" // func.func {self.sym_name}")

GetField krin-statement 

GetField(obj: SSAValue, *, field: int)

Bases: Statement

field kirin-property kw-only 

field: int = attribute(property=True)

name class-attribute instance-attribute 

name = 'getfield'

obj kirin-argument 

obj: SSAValue = argument(MethodType)

result kirin-result 

result: ResultValue = result(init=False)

traits class-attribute instance-attribute 

traits = frozenset({Pure()})

print_impl 

print_impl(printer: Printer) -> None
Source code in src/kirin/dialects/func/stmts.py 
189
190
191
192
193
194
195
196
def print_impl(self, printer: Printer) -> None:
    printer.print_name(self)
    printer.plain_print(
        "(", printer.state.ssa_id[self.obj], ", ", str(self.field), ")"
    )
    with printer.rich(style="black"):
        printer.plain_print(" : ")
        printer.print(self.result.type)

Invoke krin-statement 

Invoke(
    inputs: tuple[SSAValue, ...],
    *,
    callee: Method,
    kwargs: tuple[str, ...]
)

Bases: Statement

callee kirin-property kw-only 

callee: Method = attribute(property=True)

inputs kirin-argument 

inputs: tuple[SSAValue, ...] = argument()

kwargs kirin-property kw-only 

kwargs: tuple[str, ...] = attribute(property=True)

name class-attribute instance-attribute 

name = 'invoke'

result kirin-result 

result: ResultValue = result()

print_impl 

print_impl(printer: Printer) -> None
Source code in src/kirin/dialects/func/stmts.py 
207
208
def print_impl(self, printer: Printer) -> None:
    pprint_calllike(self, self.callee.sym_name, printer)

verify 

verify() -> None

run mandatory validation checks. This is not same as typecheck, which may be optional.

Source code in src/kirin/dialects/func/stmts.py 
210
211
212
213
214
215
216
217
218
219
220
221
222
def verify(self) -> None:
    if self.kwargs:
        for name in self.kwargs:
            if name not in self.callee.arg_names:
                raise VerificationError(
                    self,
                    f"method {self.callee.sym_name} does not have argument {name}",
                )
    elif len(self.callee.arg_names) - 1 != len(self.args):
        raise VerificationError(
            self,
            f"expected {len(self.callee.arg_names)} arguments, got {len(self.args)}",
        )

Lambda krin-statement 

Lambda(
    captured: tuple[SSAValue, ...],
    *,
    sym_name: str,
    signature: Signature,
    body: Region
)

Bases: Statement

body kirin-region kw-only 

body: Region = region(multi=True)

captured kirin-argument 

captured: tuple[SSAValue, ...] = argument()

name class-attribute instance-attribute 

name = 'lambda'

result kirin-result 

result: ResultValue = result(MethodType)

signature kirin-attribute kw-only 

signature: Signature = attribute()

sym_name kirin-property kw-only 

sym_name: str = attribute(property=True)

traits class-attribute instance-attribute 

traits = frozenset(
    {
        Pure(),
        SymbolOpInterface(),
        FuncOpCallableInterface(),
        SSACFGRegion(),
    }
)

print_impl 

print_impl(printer: Printer) -> None
Source code in src/kirin/dialects/func/stmts.py 
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
def print_impl(self, printer: Printer) -> None:
    with printer.rich(style="keyword"):
        printer.print_name(self)
    printer.plain_print(" ")

    with printer.rich(style="symbol"):
        printer.plain_print(self.sym_name)

    printer.print_seq(self.captured, prefix="(", suffix=")", delim=", ")

    with printer.rich(style="bright_black"):
        printer.plain_print(" -> ")
        printer.print(self.signature.output)

    printer.plain_print(" ")
    printer.print(self.body)

    with printer.rich(style="black"):
        printer.plain_print(f" // func.lambda {self.sym_name}")

verify 

verify() -> None

run mandatory validation checks. This is not same as typecheck, which may be optional.

Source code in src/kirin/dialects/func/stmts.py 
155
156
157
def verify(self) -> None:
    if self.body.blocks.isempty():
        raise VerificationError(self, "lambda body must not be empty")

Return krin-statement 

Return(value_or_stmt: SSAValue | Statement | None = None)

Bases: Statement

Source code in src/kirin/dialects/func/stmts.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
def __init__(self, value_or_stmt: SSAValue | Statement | None = None) -> None:
    if isinstance(value_or_stmt, SSAValue):
        args = [value_or_stmt]
    elif isinstance(value_or_stmt, Statement):
        if len(value_or_stmt._results) == 1:
            args = [value_or_stmt._results[0]]
        else:
            raise ValueError(
                f"expected a single result, got {len(value_or_stmt._results)} results from {value_or_stmt.name}"
            )
    elif value_or_stmt is None:
        args = []
    else:
        raise ValueError(f"expected SSAValue or Statement, got {value_or_stmt}")

    super().__init__(args=args, args_slice={"value": 0})

name class-attribute instance-attribute 

name = 'return'

traits class-attribute instance-attribute 

traits = frozenset({IsTerminator(), HasParent((Function))})

value kirin-argument 

value: SSAValue = argument()

print_impl 

print_impl(printer: Printer) -> None
Source code in src/kirin/dialects/func/stmts.py 
121
122
123
124
125
126
127
def print_impl(self, printer: Printer) -> None:
    with printer.rich(style="keyword"):
        printer.print_name(self)

    if self.args:
        printer.plain_print(" ")
        printer.print_seq(self.args, delim=", ")

verify 

verify() -> None

run mandatory validation checks. This is not same as typecheck, which may be optional.

Source code in src/kirin/dialects/func/stmts.py 
129
130
131
132
133
134
135
136
137
138
139
140
def verify(self) -> None:
    if not self.args:
        raise VerificationError(
            self, "return statement must have at least one value"
        )

    if len(self.args) > 1:
        raise VerificationError(
            self,
            "return statement must have at most one value"
            ", wrap multiple values in a tuple",
        )