Source code for momba.model.functions

# -*- coding:utf-8 -*-
# Copyright (C) 2021, Saarland University
# Copyright (C) 2021, Maximilian Köhl <>

from __future__ import annotations

import dataclasses as d
import typing as t

from . import errors, expressions, types

    from . import context

[docs]@d.dataclass(frozen=True) class FunctionParameter: """ A *function parameter*. Attributes ---------- name: The name of the parameter. typ: The type of the parameter. """ name: str typ: types.Type
[docs]@d.dataclass(frozen=True) class FunctionDefinition: """ A *function definition*. Attributes ---------- name: The name of the defined function. parameters: The parameters of the function. returns: The return type of the function. body: The body of the function. """ name: str parameters: t.Tuple[FunctionParameter, ...] returns: types.Type body: expressions.Expression
[docs]@d.dataclass(frozen=True) class CallExpression(expressions.Expression): """ A *call expression*. Attributes ---------- function: The name of the function to be called. arguments: The arguments to be passed to the function. """ function: str arguments: t.Tuple[expressions.Expression, ...] def infer_type(self, scope: context.Scope) -> types.Type: definition = scope.get_function(self.function) if len(self.arguments) != len(definition.parameters): raise errors.InvalidTypeError( f"function {self.function} expects {len(definition.parameters)}" f" arguments but {len(self.arguments)} are given" ) for argument, parameter in zip(self.arguments, definition.parameters): argument_type = argument.infer_type(scope) if not parameter.typ.is_assignable_from(argument_type): raise errors.InvalidTypeError( f"parameter {} of function {self.function}" f" has type {parameter.typ} but argument of type" f" {argument_type} has been provided" ) return definition.returns @property def children(self) -> t.Sequence[expressions.Expression]: return self.arguments