guppylang-internals 0.21.0__py3-none-any.whl

guppylang_internals/definition/extern.py

@@ -0,0 +1,89 @@
+import ast
+from dataclasses import dataclass, field
+
+from hugr import Node, Wire, val
+from hugr.build.dfg import DefinitionBuilder, OpVar
+
+from guppylang_internals.ast_util import AstNode
+from guppylang_internals.checker.core import Globals
+from guppylang_internals.compiler.core import CompilerContext, DFContainer
+from guppylang_internals.definition.common import CompilableDef, ParsableDef
+from guppylang_internals.definition.value import (
+    CompiledHugrNodeDef,
+    CompiledValueDef,
+    ValueDef,
+)
+from guppylang_internals.span import SourceMap
+from guppylang_internals.tys.parsing import type_from_ast
+
+
+@dataclass(frozen=True)
+class RawExternDef(ParsableDef):
+    """A raw extern symbol definition provided by the user."""
+
+    symbol: str
+    constant: bool
+    type_ast: ast.expr
+
+    description: str = field(default="extern", init=False)
+
+    def parse(self, globals: Globals, sources: SourceMap) -> "ExternDef":
+        """Parses and checks the user-provided signature of the function."""
+        return ExternDef(
+            self.id,
+            self.name,
+            self.defined_at,
+            type_from_ast(self.type_ast, globals, {}),
+            self.symbol,
+            self.constant,
+            self.type_ast,
+        )
+
+
+@dataclass(frozen=True)
+class ExternDef(RawExternDef, ValueDef, CompilableDef):
+    """An extern symbol definition."""
+
+    def compile_outer(
+        self, graph: DefinitionBuilder[OpVar], ctx: CompilerContext
+    ) -> "CompiledExternDef":
+        """Adds a Hugr constant node for the extern definition to the provided graph."""
+        # The `typ` field must be serialized at this point, to ensure that the
+        # `Extension` is serializable.
+        custom_const = {
+            "symbol": self.symbol,
+            "typ": self.ty.to_hugr(ctx)._to_serial_root(),
+            "constant": self.constant,
+        }
+        value = val.Extension(
+            name="ConstExternalSymbol",
+            typ=self.ty.to_hugr(ctx),
+            val=custom_const,
+        )
+        const_node = graph.add_const(value)
+        return CompiledExternDef(
+            self.id,
+            self.name,
+            self.defined_at,
+            self.ty,
+            self.symbol,
+            self.constant,
+            self.type_ast,
+            const_node,
+        )
+
+
+@dataclass(frozen=True)
+class CompiledExternDef(ExternDef, CompiledValueDef, CompiledHugrNodeDef):
+    """An extern symbol definition that has been compiled to a Hugr constant."""
+
+    const_node: Node
+
+    @property
+    def hugr_node(self) -> Node:
+        """The Hugr node this definition was compiled into."""
+        return self.const_node
+
+    def load(self, dfg: DFContainer, ctx: CompilerContext, node: AstNode) -> Wire:
+        """Loads the extern value into a local Hugr dataflow graph."""
+        return dfg.builder.load(self.const_node)

guppylang_internals/definition/function.py

@@ -0,0 +1,302 @@
+import ast
+import inspect
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+import hugr.build.function as hf
+import hugr.tys as ht
+from hugr import Node, Wire
+from hugr.build.dfg import DefinitionBuilder, OpVar
+from hugr.hugr.node_port import ToNode
+
+from guppylang_internals.ast_util import AstNode, annotate_location, with_loc, with_type
+from guppylang_internals.checker.cfg_checker import CheckedCFG
+from guppylang_internals.checker.core import Context, Globals, Place
+from guppylang_internals.checker.errors.generic import ExpectedError
+from guppylang_internals.checker.expr_checker import check_call, synthesize_call
+from guppylang_internals.checker.func_checker import (
+    check_global_func_def,
+    check_signature,
+    parse_function_with_docstring,
+)
+from guppylang_internals.compiler.core import (
+    CompilerContext,
+    DFContainer,
+    PartiallyMonomorphizedArgs,
+)
+from guppylang_internals.compiler.func_compiler import compile_global_func_def
+from guppylang_internals.definition.common import (
+    CheckableDef,
+    MonomorphizableDef,
+    MonomorphizedDef,
+    ParsableDef,
+    UnknownSourceError,
+)
+from guppylang_internals.definition.value import (
+    CallableDef,
+    CallReturnWires,
+    CompiledCallableDef,
+    CompiledHugrNodeDef,
+)
+from guppylang_internals.error import GuppyError
+from guppylang_internals.nodes import GlobalCall
+from guppylang_internals.span import SourceMap
+from guppylang_internals.tys.subst import Inst, Subst
+from guppylang_internals.tys.ty import FunctionType, Type, type_to_row
+
+if TYPE_CHECKING:
+    from guppylang_internals.tys.param import Parameter
+
+PyFunc = Callable[..., Any]
+
+
+@dataclass(frozen=True)
+class RawFunctionDef(ParsableDef):
+    """A raw function definition provided by the user.
+
+    The raw definition stores exactly what the user has written (i.e. the AST), without
+    any additional checking or parsing. Furthermore, we store the values of the Python
+    variables in scope at the point of definition.
+
+    Args:
+        id: The unique definition identifier.
+        name: The name of the function.
+        defined_at: The AST node where the function was defined.
+        python_func: The Python function to be defined.
+    """
+
+    python_func: PyFunc
+
+    description: str = field(default="function", init=False)
+
+    def parse(self, globals: Globals, sources: SourceMap) -> "ParsedFunctionDef":
+        """Parses and checks the user-provided signature of the function."""
+        func_ast, docstring = parse_py_func(self.python_func, sources)
+        ty = check_signature(func_ast, globals)
+        return ParsedFunctionDef(self.id, self.name, func_ast, ty, docstring)
+
+
+@dataclass(frozen=True)
+class ParsedFunctionDef(CheckableDef, CallableDef):
+    """A function definition with parsed and checked signature.
+
+    In particular, this means that we have determined a type for the function and are
+    ready to check the function body.
+
+    Args:
+        id: The unique definition identifier.
+        name: The name of the function.
+        defined_at: The AST node where the function was defined.
+        ty: The type of the function.
+        python_scope: The Python scope where the function was defined.
+        docstring: The docstring of the function.
+    """
+
+    defined_at: ast.FunctionDef
+    ty: FunctionType
+    docstring: str | None
+
+    description: str = field(default="function", init=False)
+
+    def check(self, globals: Globals) -> "CheckedFunctionDef":
+        """Type checks the body of the function."""
+        # Add python variable scope to the globals
+        cfg = check_global_func_def(self.defined_at, self.ty, globals)
+        return CheckedFunctionDef(
+            self.id,
+            self.name,
+            self.defined_at,
+            self.ty,
+            self.docstring,
+            cfg,
+        )
+
+    def check_call(
+        self, args: list[ast.expr], ty: Type, node: AstNode, ctx: Context
+    ) -> tuple[ast.expr, Subst]:
+        """Checks the return type of a function call against a given type."""
+        # Use default implementation from the expression checker
+        args, subst, inst = check_call(self.ty, args, ty, node, ctx)
+        node = with_loc(node, GlobalCall(def_id=self.id, args=args, type_args=inst))
+        return node, subst
+
+    def synthesize_call(
+        self, args: list[ast.expr], node: AstNode, ctx: Context
+    ) -> tuple[ast.expr, Type]:
+        """Synthesizes the return type of a function call."""
+        # Use default implementation from the expression checker
+        args, ty, inst = synthesize_call(self.ty, args, node, ctx)
+        node = with_loc(node, GlobalCall(def_id=self.id, args=args, type_args=inst))
+        return with_type(ty, node), ty
+
+
+@dataclass(frozen=True)
+class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
+    """Type checked version of a user-defined function that is ready to be compiled.
+
+    In particular, this means that we have a constructed and type checked a control-flow
+    graph for the function body.
+
+    Args:
+        id: The unique definition identifier.
+        name: The name of the function.
+        defined_at: The AST node where the function was defined.
+        ty: The type of the function.
+        python_scope: The Python scope where the function was defined.
+        docstring: The docstring of the function.
+        cfg: The type- and linearity-checked CFG for the function body.
+    """
+
+    cfg: CheckedCFG[Place]
+
+    @property
+    def params(self) -> "Sequence[Parameter]":
+        """Generic parameters of this function."""
+        return self.ty.params
+
+    def monomorphize(
+        self,
+        module: DefinitionBuilder[OpVar],
+        mono_args: "PartiallyMonomorphizedArgs",
+        ctx: "CompilerContext",
+    ) -> "CompiledFunctionDef":
+        """Adds a Hugr `FuncDefn` node for the (partially) monomorphized function to the
+        Hugr.
+
+        Note that we don't compile the function body at this point since we don't have
+        access to the other compiled functions yet. The body is compiled later in
+        `CompiledFunctionDef.compile_inner()`.
+        """
+        mono_ty = self.ty.instantiate_partial(mono_args)
+        hugr_ty = mono_ty.to_hugr_poly(ctx)
+        func_def = module.module_root_builder().define_function(
+            self.name, hugr_ty.body.input, hugr_ty.body.output, hugr_ty.params
+        )
+        return CompiledFunctionDef(
+            self.id,
+            self.name,
+            self.defined_at,
+            mono_args,
+            mono_ty,
+            self.docstring,
+            self.cfg,
+            func_def,
+        )
+
+
+@dataclass(frozen=True)
+class CompiledFunctionDef(
+    CheckedFunctionDef, CompiledCallableDef, MonomorphizedDef, CompiledHugrNodeDef
+):
+    """A function definition with a corresponding Hugr node.
+
+    Args:
+        id: The unique definition identifier.
+        name: The name of the function.
+        defined_at: The AST node where the function was defined.
+        mono_args: Partial monomorphization of the generic type parameters.
+        ty: The type of the function after partial monomorphization.
+        python_scope: The Python scope where the function was defined.
+        docstring: The docstring of the function.
+        cfg: The type- and linearity-checked CFG for the function body.
+        func_def: The Hugr function definition.
+    """
+
+    func_def: hf.Function
+
+    @property
+    def hugr_node(self) -> Node:
+        """The Hugr node this definition was compiled into."""
+        return self.func_def.parent_node
+
+    def load_with_args(
+        self,
+        type_args: Inst,
+        dfg: DFContainer,
+        ctx: CompilerContext,
+        node: AstNode,
+    ) -> Wire:
+        """Loads the function as a value into a local Hugr dataflow graph."""
+        return load_with_args(type_args, dfg, self.ty, self.func_def)
+
+    def compile_call(
+        self,
+        args: list[Wire],
+        type_args: Inst,
+        dfg: DFContainer,
+        ctx: CompilerContext,
+        node: AstNode,
+    ) -> CallReturnWires:
+        """Compiles a call to the function."""
+        return compile_call(args, type_args, dfg, self.ty, self.func_def)
+
+    def compile_inner(self, globals: CompilerContext) -> None:
+        """Compiles the body of the function."""
+        compile_global_func_def(self, self.func_def, globals)
+
+
+def load_with_args(
+    type_args: Inst,
+    dfg: DFContainer,
+    ty: FunctionType,
+    func: ToNode,
+) -> Wire:
+    """Loads the function as a value into a local Hugr dataflow graph."""
+    func_ty: ht.FunctionType = ty.instantiate(type_args).to_hugr(dfg.ctx)
+    type_args = [ta.to_hugr(dfg.ctx) for ta in type_args]
+    return dfg.builder.load_function(func, func_ty, type_args)
+
+
+def compile_call(
+    args: list[Wire],
+    type_args: Inst,  # Non-monomorphized type args only
+    dfg: DFContainer,
+    ty: FunctionType,
+    func: ToNode,
+) -> CallReturnWires:
+    """Compiles a call to the function."""
+    func_ty: ht.FunctionType = ty.instantiate(type_args).to_hugr(dfg.ctx)
+    type_args = [arg.to_hugr(dfg.ctx) for arg in type_args]
+    num_returns = len(type_to_row(ty.output))
+    call = dfg.builder.call(func, *args, instantiation=func_ty, type_args=type_args)
+    return CallReturnWires(
+        regular_returns=list(call[:num_returns]),
+        inout_returns=list(call[num_returns:]),
+    )
+
+
+def parse_py_func(f: PyFunc, sources: SourceMap) -> tuple[ast.FunctionDef, str | None]:
+    source_lines, line_offset = inspect.getsourcelines(f)
+    source, func_ast, line_offset = parse_source(source_lines, line_offset)
+    file = inspect.getsourcefile(f)
+    if file is None:
+        raise GuppyError(UnknownSourceError(None, f))
+    sources.add_file(file)
+    annotate_location(func_ast, source, file, line_offset)
+    if not isinstance(func_ast, ast.FunctionDef):
+        raise GuppyError(ExpectedError(func_ast, "a function definition"))
+    return parse_function_with_docstring(func_ast)
+
+
+def parse_source(source_lines: list[str], line_offset: int) -> tuple[str, ast.AST, int]:
+    """Parses a list of source lines into an AST object.
+
+    Also takes care of correctly parsing source that is indented.
+
+    Returns the full source, the parsed AST node, and a potentially updated line number
+    offset.
+    """
+    source = "".join(source_lines)  # Lines already have trailing \n's
+    if source_lines[0][0].isspace():
+        # This means the function is indented, so we cannot parse it straight away.
+        # Running `textwrap.dedent` would mess up the column number in spans. Instead,
+        # we'll just wrap the source into a dummy class definition so the indent becomes
+        # valid
+        cls_node = ast.parse("class _:\n" + source).body[0]
+        assert isinstance(cls_node, ast.ClassDef)
+        node = cls_node.body[0]
+        line_offset -= 1
+    else:
+        node = ast.parse(source).body[0]
+    return source, node, line_offset

guppylang_internals/definition/overloaded.py

@@ -0,0 +1,150 @@
+import ast
+from contextlib import suppress
+from dataclasses import dataclass, field
+from typing import ClassVar, NoReturn
+
+from hugr import Wire
+
+from guppylang_internals.ast_util import AstNode
+from guppylang_internals.checker.core import Context
+from guppylang_internals.checker.expr_checker import ExprSynthesizer
+from guppylang_internals.compiler.core import CompilerContext, DFContainer
+from guppylang_internals.definition.common import (
+    DefId,
+)
+from guppylang_internals.definition.value import (
+    CallableDef,
+    CallReturnWires,
+    CompiledCallableDef,
+)
+from guppylang_internals.diagnostic import Error, Note
+from guppylang_internals.error import GuppyError, InternalGuppyError
+from guppylang_internals.span import Span, to_span
+from guppylang_internals.tys.printing import signature_to_str
+from guppylang_internals.tys.subst import Inst, Subst
+from guppylang_internals.tys.ty import FunctionType, Type
+
+
+@dataclass(frozen=True)
+class OverloadNoMatchError(Error):
+    title: ClassVar[str] = "Invalid call of overloaded function"
+    func: str
+    arg_tys: list[Type]
+    return_ty: Type | None
+
+    @property
+    def rendered_span_label(self) -> str:
+        stem = f"No variant of overloaded function `{self.func}` "
+        match self.arg_tys:
+            case []:
+                stem += "takes 0 arguments"
+            case [ty]:
+                stem += f"takes a `{ty}` argument"
+            case tys:
+                args = ", ".join(f"`{ty}`" for ty in tys)
+                stem += f"takes arguments {args}"
+        if self.return_ty:
+            stem += f" and returns `{self.return_ty}`"
+        return stem
+
+
+@dataclass(frozen=True)
+class AvailableOverloadsHint(Note):
+    func_name: str
+    variants: list[FunctionType]
+
+    @property
+    def rendered_message(self) -> str:
+        return "Available overloads are:\n" + "\n".join(
+            f"  {signature_to_str(self.func_name, ty)}" for ty in self.variants
+        )
+
+
+@dataclass(frozen=True)
+class OverloadHigherOrderError(Error):
+    title: ClassVar[str] = "Higher-order overloaded function"
+    span_label: ClassVar[str] = (
+        "Overloaded function `{func}` may not be used as a higher-order value"
+    )
+    func: str
+
+
+@dataclass(frozen=True)
+class OverloadedFunctionDef(CompiledCallableDef, CallableDef):
+    func_ids: list[DefId]
+    description: str = field(default="overloaded function", init=False)
+
+    def load(self, dfg: DFContainer, ctx: CompilerContext, node: AstNode) -> Wire:
+        raise GuppyError(OverloadHigherOrderError(node, self.name))
+
+    def check_call(
+        self, args: list[ast.expr], ty: Type, node: AstNode, ctx: Context
+    ) -> tuple[ast.expr, Subst]:
+        available_sigs: list[FunctionType] = []
+        for def_id in self.func_ids:
+            defn = ctx.globals[def_id]
+            assert isinstance(defn, CallableDef)
+            available_sigs.append(defn.ty)
+            with suppress(GuppyError):
+                return defn.check_call(args, ty, node, ctx)
+        return self._call_error(args, node, ctx, available_sigs, ty)
+
+    def synthesize_call(
+        self, args: list[ast.expr], node: AstNode, ctx: "Context"
+    ) -> tuple[ast.expr, Type]:
+        available_sigs: list[FunctionType] = []
+        for def_id in self.func_ids:
+            defn = ctx.globals[def_id]
+            assert isinstance(defn, CallableDef)
+            available_sigs.append(defn.ty)
+            with suppress(GuppyError):
+                return defn.synthesize_call(args, node, ctx)
+        return self._call_error(args, node, ctx, available_sigs)
+
+    def _call_error(
+        self,
+        args: list[ast.expr],
+        node: AstNode,
+        ctx: "Context",
+        available_sigs: list[FunctionType],
+        return_ty: Type | None = None,
+    ) -> NoReturn:
+        if args and not return_ty:
+            start = to_span(args[0]).start
+            end = to_span(args[-1]).end
+            span = Span(start, end)
+        else:
+            span = to_span(node)
+
+        synth = ExprSynthesizer(ctx)
+        arg_tys = [synth.synthesize(arg)[1] for arg in args]
+        err = OverloadNoMatchError(span, self.name, arg_tys, return_ty)
+        err.add_sub_diagnostic(AvailableOverloadsHint(None, self.name, available_sigs))
+        raise GuppyError(err)
+
+    def compile_call(
+        self,
+        args: list[Wire],
+        type_args: Inst,
+        dfg: "DFContainer",
+        ctx: "CompilerContext",
+        node: AstNode,
+    ) -> "CallReturnWires":
+        # This should never be called: Checking the call replaces it with the concrete
+        # implementation
+        raise InternalGuppyError(
+            "OverloadedFunctionDef.compile_call shouldn't be invoked"
+        )
+
+    def load_with_args(
+        self,
+        type_args: Inst,
+        dfg: "DFContainer",
+        ctx: "CompilerContext",
+        node: AstNode,
+    ) -> Wire:
+        # This should never be called: During checking we should have already ruled out
+        # that overloaded functions are used as higher-order values.
+        raise InternalGuppyError(
+            "OverloadedFunctionDef.load_with_args shouldn't be invoked"
+        )

guppylang_internals/definition/parameter.py

@@ -0,0 +1,82 @@
+import ast
+from abc import abstractmethod
+from dataclasses import dataclass, field
+from typing import ClassVar
+
+from guppylang_internals.checker.core import Globals
+from guppylang_internals.definition.common import CompiledDef, Definition, ParsableDef
+from guppylang_internals.diagnostic import Error
+from guppylang_internals.error import GuppyError, InternalGuppyError
+from guppylang_internals.span import SourceMap
+from guppylang_internals.tys.param import ConstParam, Parameter, TypeParam
+from guppylang_internals.tys.ty import Type
+
+
+@dataclass(frozen=True)
+class LinearConstVarError(Error):
+    title: ClassVar[str] = "Invalid const variable"
+    span_label: ClassVar[str] = (
+        "Const variable `{name}` is not allowed have {thing} type `{ty}`"
+    )
+    name: str
+    ty: Type
+
+    @property
+    def thing(self) -> str:
+        return "non-copyable" if not self.ty.copyable else "non-droppable"
+
+
+class ParamDef(Definition):
+    """Abstract base class for type parameter definitions."""
+
+    @abstractmethod
+    def to_param(self, idx: int) -> Parameter:
+        """Creates a parameter from this definition."""
+
+
+@dataclass(frozen=True)
+class TypeVarDef(ParamDef, CompiledDef):
+    """A type variable definition."""
+
+    must_be_copyable: bool
+    must_be_droppable: bool
+
+    description: str = field(default="type variable", init=False)
+
+    def to_param(self, idx: int) -> TypeParam:
+        """Creates a parameter from this definition."""
+        return TypeParam(idx, self.name, self.must_be_copyable, self.must_be_droppable)
+
+
+@dataclass(frozen=True)
+class RawConstVarDef(ParamDef, ParsableDef):
+    """A constant variable definition whose type is not parsed yet."""
+
+    type_ast: ast.expr
+    description: str = field(default="const variable", init=False)
+
+    def parse(self, globals: Globals, sources: SourceMap) -> "ConstVarDef":
+        from guppylang_internals.tys.parsing import type_from_ast
+
+        ty = type_from_ast(self.type_ast, globals, {})
+        if not ty.copyable or not ty.droppable:
+            raise GuppyError(LinearConstVarError(self.type_ast, self.name, ty))
+        return ConstVarDef(self.id, self.name, self.defined_at, ty)
+
+    def to_param(self, idx: int) -> Parameter:
+        raise InternalGuppyError(
+            "RawConstVarDef.to_param: Parameter conversion only possible after parsing"
+        )
+
+
+@dataclass(frozen=True)
+class ConstVarDef(ParamDef, CompiledDef):
+    """A constant variable definition."""
+
+    ty: Type
+
+    description: str = field(default="const variable", init=False)
+
+    def to_param(self, idx: int) -> ConstParam:
+        """Creates a parameter from this definition."""
+        return ConstParam(idx, self.name, self.ty)