types

Parse type annotations and synthesize default values for typed declarations.

Classes:

• TypeParserMixin –

TypeParserMixin

Bases: ParserMixinBase

Methods:

• get_tok_precedence –
• parse_assert_stmt –
• parse_block –
• parse_class_decl –
• parse_declaration_prefixes –
• parse_expression –
• parse_extern –
• parse_for_stmt –
• parse_function –
• parse_if_stmt –
• parse_import_stmt –
• parse_prototype –
• parse_return_function –
• parse_template_argument_list –
• parse_type –
• parse_var_expr –
• parse_while_stmt –

get_tok_precedence

get_tok_precedence() -> int

Source code in packages/arx/src/arx/parser/base.py

def get_tok_precedence(self) -> int:
    """
    title: Get the precedence of the pending binary operator token.
    returns:
      type: int
    """
    raise NotImplementedError

parse_assert_stmt

parse_assert_stmt() -> AssertStmt

Source code in packages/arx/src/arx/parser/base.py

def parse_assert_stmt(self) -> astx.AssertStmt:
    """
    title: Parse one fatal assertion statement.
    returns:
      type: astx.AssertStmt
    """
    raise NotImplementedError

parse_block

parse_block(
    allow_docstring: bool = False,
    declared_names: tuple[str, ...] = (),
    declared_lists: tuple[str, ...] = (),
    declared_tensors: dict[str, TensorBinding | None]
    | None = None,
) -> Block

Source code in packages/arx/src/arx/parser/base.py

def parse_block(
    self,
    allow_docstring: bool = False,
    declared_names: tuple[str, ...] = (),
    declared_lists: tuple[str, ...] = (),
    declared_tensors: dict[str, TensorBinding | None] | None = None,
) -> astx.Block:
    """
    title: Parse one block of nodes.
    parameters:
      allow_docstring:
        type: bool
      declared_names:
        type: tuple[str, Ellipsis]
      declared_lists:
        type: tuple[str, Ellipsis]
      declared_tensors:
        type: dict[str, TensorBinding | None] | None
    returns:
      type: astx.Block
    """
    del allow_docstring, declared_names, declared_lists, declared_tensors
    raise NotImplementedError

parse_class_decl

parse_class_decl(
    annotations: ParsedAnnotation | None = None,
) -> ClassDefStmt

Source code in packages/arx/src/arx/parser/base.py

def parse_class_decl(
    self,
    annotations: ParsedAnnotation | None = None,
) -> astx.ClassDefStmt:
    """
    title: Parse one class declaration.
    parameters:
      annotations:
        type: ParsedAnnotation | None
    returns:
      type: astx.ClassDefStmt
    """
    del annotations
    raise NotImplementedError

parse_declaration_prefixes

parse_declaration_prefixes(
    *, body_indent: int | None = None
) -> ParsedDeclarationPrefixes

Source code in packages/arx/src/arx/parser/base.py

def parse_declaration_prefixes(
    self,
    *,
    body_indent: int | None = None,
) -> ParsedDeclarationPrefixes:
    """
    title: Parse declaration prefixes before one declaration.
    parameters:
      body_indent:
        type: int | None
    returns:
      type: ParsedDeclarationPrefixes
    """
    del body_indent
    raise NotImplementedError

parse_expression

parse_expression() -> AST

Source code in packages/arx/src/arx/parser/base.py

def parse_expression(self) -> astx.AST:
    """
    title: Parse one expression.
    returns:
      type: astx.AST
    """
    raise NotImplementedError

parse_extern

parse_extern() -> FunctionPrototype

Source code in packages/arx/src/arx/parser/base.py

def parse_extern(self) -> astx.FunctionPrototype:
    """
    title: Parse one extern declaration.
    returns:
      type: astx.FunctionPrototype
    """
    raise NotImplementedError

parse_for_stmt

parse_for_stmt() -> AST

Source code in packages/arx/src/arx/parser/base.py

def parse_for_stmt(self) -> astx.AST:
    """
    title: Parse one for-loop expression.
    returns:
      type: astx.AST
    """
    raise NotImplementedError

parse_function

parse_function(
    template_params: tuple[TemplateParam, ...] = (),
) -> FunctionDef

Source code in packages/arx/src/arx/parser/base.py

def parse_function(
    self,
    template_params: tuple[astx.TemplateParam, ...] = (),
) -> astx.FunctionDef:
    """
    title: Parse one function definition.
    parameters:
      template_params:
        type: tuple[astx.TemplateParam, Ellipsis]
    returns:
      type: astx.FunctionDef
    """
    del template_params
    raise NotImplementedError

parse_if_stmt

parse_if_stmt() -> IfStmt

Source code in packages/arx/src/arx/parser/base.py

def parse_if_stmt(self) -> astx.IfStmt:
    """
    title: Parse one if expression.
    returns:
      type: astx.IfStmt
    """
    raise NotImplementedError

parse_import_stmt

parse_import_stmt() -> ImportStmt | ImportFromStmt

Source code in packages/arx/src/arx/parser/base.py

def parse_import_stmt(
    self,
) -> astx.ImportStmt | astx.ImportFromStmt:
    """
    title: Parse one import statement.
    returns:
      type: astx.ImportStmt | astx.ImportFromStmt
    """
    raise NotImplementedError

parse_prototype

parse_prototype(expect_colon: bool) -> FunctionPrototype

Source code in packages/arx/src/arx/parser/base.py

def parse_prototype(
    self,
    expect_colon: bool,
) -> astx.FunctionPrototype:
    """
    title: Parse one function or extern prototype.
    parameters:
      expect_colon:
        type: bool
    returns:
      type: astx.FunctionPrototype
    """
    del expect_colon
    raise NotImplementedError

parse_return_function

parse_return_function() -> FunctionReturn

Source code in packages/arx/src/arx/parser/base.py

def parse_return_function(self) -> astx.FunctionReturn:
    """
    title: Parse one return expression.
    returns:
      type: astx.FunctionReturn
    """
    raise NotImplementedError

parse_template_argument_list

parse_template_argument_list() -> tuple[DataType, ...]

Source code in packages/arx/src/arx/parser/base.py

def parse_template_argument_list(
    self,
) -> tuple[astx.DataType, ...]:
    """
    title: Parse one explicit template-argument list.
    returns:
      type: tuple[astx.DataType, Ellipsis]
    """
    raise NotImplementedError

parse_type

parse_type(
    *,
    allow_template_vars: bool = True,
    allow_union: bool = False,
    type_context: TypeUseContext = GENERAL,
) -> DataType

Source code in packages/arx/src/arx/parser/types.py

def parse_type(
    self,
    *,
    allow_template_vars: bool = True,
    allow_union: bool = False,
    type_context: TypeUseContext = TypeUseContext.GENERAL,
) -> astx.DataType:
    """
    title: Parse a type annotation.
    parameters:
      allow_template_vars:
        type: bool
      allow_union:
        type: bool
      type_context:
        type: TypeUseContext
    returns:
      type: astx.DataType
    """
    if self.tokens.cur_tok.kind == TokenKind.none_literal:
        self.tokens.get_next_token()  # eat none
        type_: astx.DataType = astx.NoneType()
    else:
        if self.tokens.cur_tok.kind != TokenKind.identifier:
            raise ParserException("Parser: Expected a type name")

        type_name = cast(str, self.tokens.cur_tok.value)
        template_bound = None
        if allow_template_vars:
            template_bound = self._lookup_template_bound(type_name)

        if type_name == "list":
            self.tokens.get_next_token()  # eat list
            self._consume_operator("[")
            elem_type = self.parse_type(
                allow_template_vars=allow_template_vars,
                allow_union=allow_union,
                type_context=TypeUseContext.NESTED,
            )
            if self._is_operator(","):
                raise ParserException(
                    "List types accept exactly one element type."
                )
            self._consume_operator("]")
            type_ = astx.ListType([cast(astx.ExprType, elem_type)])
        elif type_name == "tensor":
            self.tokens.get_next_token()  # eat tensor
            self._consume_operator("[")
            elem_type = self.parse_type(
                allow_template_vars=allow_template_vars,
                allow_union=allow_union,
                type_context=TypeUseContext.NESTED,
            )
            shape: list[int] = []
            runtime_shape = False
            if self._is_operator(","):
                self._consume_operator(",")
                if self._is_operator("."):
                    self._consume_runtime_shape_marker()
                    runtime_shape = True
                else:
                    while True:
                        dimension_token = self.tokens.cur_tok
                        if dimension_token.kind != TokenKind.int_literal:
                            raise ParserException(
                                "Tensor dimensions must be integer "
                                "literals."
                            )
                        shape.append(cast(int, dimension_token.value))
                        self.tokens.get_next_token()
                        if not self._is_operator(","):
                            break
                        self._consume_operator(",")
                        if self._is_operator("."):
                            self._consume_runtime_shape_marker()
                            raise ParserException(
                                "Runtime-shaped tensor ellipsis cannot "
                                "be combined with static dimensions."
                            )

            if runtime_shape and self._is_operator(","):
                raise ParserException(
                    "Runtime-shaped tensor ellipsis cannot be combined "
                    "with static dimensions."
                )

            self._consume_operator("]")
            if runtime_shape:
                self._ensure_runtime_layout_allowed(
                    "tensor",
                    type_context,
                )
                try:
                    type_ = runtime_tensor_type(elem_type)
                except ValueError as err:
                    raise ParserException(str(err)) from err
            else:
                if not shape:
                    raise ParserException(
                        "Tensor types require at least one static shape "
                        "dimension, for example tensor[i32, 4]. Use "
                        "tensor[i32, ...] for runtime-shaped tensor "
                        "parameters."
                    )
                try:
                    type_ = tensor_type(elem_type, tuple(shape))
                except ValueError as err:
                    raise ParserException(str(err)) from err
        else:
            type_map: dict[str, astx.DataType] = {
                "i8": astx.Int8(),
                "i16": astx.Int16(),
                "i32": astx.Int32(),
                "i64": astx.Int64(),
                "int8": astx.Int8(),
                "int16": astx.Int16(),
                "int32": astx.Int32(),
                "int64": astx.Int64(),
                "f16": astx.Float16(),
                "f32": astx.Float32(),
                "f64": astx.Float64(),
                "float16": astx.Float16(),
                "float32": astx.Float32(),
                "float64": astx.Float64(),
                "bool": astx.Boolean(),
                "boolean": astx.Boolean(),
                "none": astx.NoneType(),
                "str": astx.String(),
                "string": astx.String(),
                "char": astx.Int8(),
                "datetime": astx.DateTime(),
                "timestamp": astx.Timestamp(),
                "date": astx.Date(),
                "time": astx.Time(),
            }

            self.tokens.get_next_token()  # eat type identifier
            if type_name in type_map:
                type_ = type_map[type_name]
            elif template_bound is not None:
                type_ = astx.TemplateTypeVar(
                    type_name,
                    bound=template_bound,
                )
            elif type_name in self.known_class_names:
                type_ = astx.ClassType(type_name)
            else:
                raise ParserException(
                    f"Parser: Unknown type '{type_name}'."
                )

    if not allow_union or not self._is_operator("|"):
        return type_

    members = [type_]
    while self._is_operator("|"):
        self._consume_operator("|")
        members.append(
            self.parse_type(
                allow_template_vars=allow_template_vars,
                allow_union=False,
                type_context=type_context,
            )
        )

    return astx.UnionType(members)

parse_var_expr

parse_var_expr() -> VariableDeclaration

Source code in packages/arx/src/arx/parser/base.py

def parse_var_expr(self) -> astx.VariableDeclaration:
    """
    title: Parse one typed variable declaration.
    returns:
      type: astx.VariableDeclaration
    """
    raise NotImplementedError

parse_while_stmt

parse_while_stmt() -> WhileStmt

Source code in packages/arx/src/arx/parser/base.py

def parse_while_stmt(self) -> astx.WhileStmt:
    """
    title: Parse one while expression.
    returns:
      type: astx.WhileStmt
    """
    raise NotImplementedError