imports

Parse import statements and grouped import syntax while reusing the shared parser core helpers.

Classes:

• ImportParserMixin –

ImportParserMixin

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_grouped_import_names –
• parse_if_stmt –
• parse_import_alias –
• parse_import_from_module_path –
• parse_import_stmt –
• parse_module_path –
• 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_grouped_import_names

parse_grouped_import_names() -> list[AliasExpr]

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

def parse_grouped_import_names(self) -> list[astx.AliasExpr]:
    """
    title: Parse grouped named imports.
    returns:
      type: list[astx.AliasExpr]
    """
    self._consume_operator("(")
    self._skip_import_layout()

    if self._is_operator(")"):
        raise ParserException("empty grouped imports are not allowed")

    names: list[astx.AliasExpr] = []
    while True:
        if self._is_identifier_value("as"):
            raise ParserException(
                "alias requires an import target before 'as'"
            )
        if self.tokens.cur_tok.kind != TokenKind.identifier:
            raise ParserException(
                "Expected imported name in grouped import list."
            )

        name = cast(str, self.tokens.cur_tok.value)
        name_loc = self.tokens.cur_tok.location
        self.tokens.get_next_token()
        alias_name = self.parse_import_alias()
        names.append(astx.AliasExpr(name, asname=alias_name, loc=name_loc))

        self._skip_import_layout()
        if self._is_operator(")"):
            break

        self._consume_operator(",")
        self._skip_import_layout()
        if self._is_operator(")"):
            break

    self._consume_operator(")")
    return names

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_alias

parse_import_alias() -> str

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

def parse_import_alias(self) -> str:
    """
    title: Parse one optional import alias.
    returns:
      type: str
    """
    if not self._is_identifier_value("as"):
        return ""

    self._consume_identifier_value("as")
    if self.tokens.cur_tok.kind != TokenKind.identifier:
        raise ParserException("Expected alias name after 'as'.")

    alias_name = cast(str, self.tokens.cur_tok.value)
    self.tokens.get_next_token()
    return alias_name

parse_import_from_module_path

parse_import_from_module_path() -> tuple[int, str]

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

def parse_import_from_module_path(self) -> tuple[int, str]:
    """
    title: Parse one absolute or relative module path for from-imports.
    returns:
      type: tuple[int, str]
    """
    level = 0
    while self._is_operator("."):
        self._consume_operator(".")
        level += 1

    if level > 0 and self.tokens.cur_tok.kind != TokenKind.identifier:
        raise ParserException(
            "Relative imports require a module path after leading '.'."
        )

    return level, self.parse_module_path()

parse_import_stmt

parse_import_stmt() -> ImportStmt | ImportFromStmt

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

def parse_import_stmt(self) -> astx.ImportStmt | astx.ImportFromStmt:
    """
    title: Parse one import statement.
    returns:
      type: astx.ImportStmt | astx.ImportFromStmt
    """
    import_loc = self.tokens.cur_tok.location
    self.tokens.get_next_token()  # eat import

    if self._is_operator("("):
        names = self.parse_grouped_import_names()
        if not self._is_identifier_value("from"):
            raise ParserException(
                "Grouped imports require 'from <module.path>'."
            )
        self._consume_identifier_value("from")
        level, module_path = self.parse_import_from_module_path()
        self._reject_public_builtin_import(module_path, level)
        return astx.ImportFromStmt(
            names=names,
            module=module_path,
            level=level,
            loc=import_loc,
        )

    if self._is_identifier_value("from"):
        raise ParserException(
            "Expected module path or imported name after 'import'."
        )

    if self._is_identifier_value("as"):
        raise ParserException(
            "alias requires an import target before 'as'"
        )

    if self.tokens.cur_tok.kind != TokenKind.identifier:
        raise ParserException(
            "Expected module path or imported name after 'import'."
        )

    target_name = cast(str, self.tokens.cur_tok.value)
    target_loc = self.tokens.cur_tok.location
    self.tokens.get_next_token()

    if self._is_operator("."):
        module_path = self.parse_module_path(prefix=target_name)
        alias_name = self.parse_import_alias()
        if self._is_identifier_value("from"):
            raise ParserException("Module imports do not use 'from'.")
        self._reject_public_builtin_import(module_path, level=0)
        return astx.ImportStmt(
            [
                astx.AliasExpr(
                    module_path,
                    asname=alias_name,
                    loc=target_loc,
                )
            ],
            loc=import_loc,
        )

    alias_name = self.parse_import_alias()
    if self._is_identifier_value("from"):
        self._consume_identifier_value("from")
        level, module_path = self.parse_import_from_module_path()
        self._reject_public_builtin_import(module_path, level)
        return astx.ImportFromStmt(
            names=[
                astx.AliasExpr(
                    target_name,
                    asname=alias_name,
                    loc=target_loc,
                )
            ],
            module=module_path,
            level=level,
            loc=import_loc,
        )

    if self._is_operator(","):
        raise ParserException("Grouped imports require parentheses.")

    if self._is_operator("("):
        raise ParserException(
            "Parentheses are only supported for grouped named imports."
        )

    self._reject_public_builtin_import(target_name, level=0)
    return astx.ImportStmt(
        [astx.AliasExpr(target_name, asname=alias_name, loc=target_loc)],
        loc=import_loc,
    )

parse_module_path

parse_module_path(prefix: str | None = None) -> str

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

def parse_module_path(self, prefix: str | None = None) -> str:
    """
    title: Parse one dotted module path.
    parameters:
      prefix:
        type: str | None
    returns:
      type: str
    """
    parts: list[str] = []
    if prefix is not None:
        parts.append(prefix)
    else:
        if self.tokens.cur_tok.kind != TokenKind.identifier:
            raise ParserException("Expected module path.")
        parts.append(cast(str, self.tokens.cur_tok.value))
        self.tokens.get_next_token()

    while self._is_operator("."):
        self._consume_operator(".")
        if self.tokens.cur_tok.kind != TokenKind.identifier:
            raise ParserException(
                "Expected identifier after '.' in module path."
            )
        parts.append(cast(str, self.tokens.cur_tok.value))
        self.tokens.get_next_token()

    return ".".join(parts)

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/base.py

def parse_type(
    self,
    *,
    allow_template_vars: bool = True,
    allow_union: bool = False,
    type_context: TypeUseContext = TypeUseContext.GENERAL,
) -> astx.DataType:
    """
    title: Parse one type annotation.
    parameters:
      allow_template_vars:
        type: bool
      allow_union:
        type: bool
      type_context:
        type: TypeUseContext
    returns:
      type: astx.DataType
    """
    del allow_template_vars, allow_union, type_context
    raise NotImplementedError

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