fpy2 0.0.3__tar.gz → 0.0.4__tar.gz

{fpy2-0.0.3 → fpy2-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fpy2
-Version: 0.0.3
+Version: 0.0.4
 Summary: An embedded DSL for numerical computing
 Author-email: Brett Saiki <bsaiki@cs.washington.edu>
 License-Expression: MIT
@@ -27,9 +27,9 @@ Dynamic: license-file
 
 An embedded Python DSL for specifying and simulating numerical algorithms.
 
-Important lints:
+Important links:
  - PyPI package: [fpy2](https://pypi.org/project/fpy2/)
- - Documentation: [fpy2.readthedocs.io](https://fpy2.readthedocs.io/)
+ - Documentation: [fpy.readthedocs.io](https://fpy.readthedocs.io/)
  - GitHub: [fpy](https://github.com/bksaiki/fpy)
 
 ## Installation

{fpy2-0.0.3 → fpy2-0.0.4}/README.md

@@ -2,9 +2,9 @@
 
 An embedded Python DSL for specifying and simulating numerical algorithms.
 
-Important lints:
+Important links:
  - PyPI package: [fpy2](https://pypi.org/project/fpy2/)
- - Documentation: [fpy2.readthedocs.io](https://fpy2.readthedocs.io/)
+ - Documentation: [fpy.readthedocs.io](https://fpy.readthedocs.io/)
  - GitHub: [fpy](https://github.com/bksaiki/fpy)
 
 ## Installation

fpy2-0.0.4/fpy2/__init__.py

@@ -0,0 +1,113 @@
+"""
+FPy is a library for simulating numerical programs
+with many different number systems.
+
+It provides an embedded DSL for specifying programs via its `@fpy` decorator.
+The language has a runtime that can simulate programs
+under different number systems and compilers to other languages.
+
+The numbers library supports many different number types including:
+
+ - multiprecision floating point (`MPFloatContext`)
+ - multiprecision floatingpoint with subnormalization (`MPSFloatContext`)
+ - bounded, multiprecision floating point (`MPBFloatContext`)
+ - IEEE 754 floating point (`IEEEContext`)
+
+These number systems guarantee correct rounding via MPFR.
+"""
+
+from .number import (
+    # number types
+    Float,
+    RealFloat,
+    # abstract context types
+    Context,
+    OrdinalContext,
+    SizedContext,
+    EncodableContext,
+    # concrete context types
+    ExtFloatContext,
+    FixedContext,
+    MPFixedContext,
+    MPFloatContext,
+    MPBFixedContext,
+    MPBFloatContext,
+    MPSFloatContext,
+    IEEEContext,
+    RealContext,
+    # rounding utilities
+    RoundingMode,
+    RoundingDirection, RM,
+    # encoding utilities
+    ExtFloatNanKind,
+    FixedOverflowKind, OF,
+    # type aliases
+    FP256, FP128, FP64, FP32, FP16,
+    TF32, BF16,
+    S1E5M2, S1E4M3,
+    MX_E5M2, MX_E4M3, MX_E3M2, MX_E2M3, MX_E2M1,
+    FP8P1, FP8P2, FP8P3, FP8P4, FP8P5, FP8P6, FP8P7,
+    INTEGER,
+    SINT8, SINT16, SINT32, SINT64,
+    UINT8, UINT16, UINT32, UINT64
+)
+
+from .fpc_context import FPCoreContext, NoSuchContextError
+
+from .decorator import fpy, pattern, fpy_prim
+
+from .backend import (
+    Backend,
+    FPCoreCompiler
+)
+
+from .interpret import (
+    Interpreter,
+    PythonInterpreter,
+    DefaultInterpreter,
+    set_default_interpreter,
+    get_default_interpreter,
+)
+
+from .function import Function
+from .env import ForeignEnv
+
+from .utils import (
+    fraction,
+    digits_to_fraction as digits,
+    decnum_to_fraction as decnum,
+    hexnum_to_fraction as hexnum,
+)
+
+###########################################################
+# Re-exports
+
+from titanfp.titanic.ndarray import NDArray
+
+###########################################################
+# typing hints
+
+import typing
+
+from typing import Literal as Dim
+
+_Dims = typing.TypeVarTuple('_Dims')
+_DType = typing.TypeVar('_DType')
+
+class Tensor(tuple, typing.Generic[*_Dims, _DType]):
+    """
+    FPy type hint for a homogenous tensor object::
+
+        from fpy2 import Tensor, Real
+        from typing import TypeAlias
+
+        MatrixN: TypeAlias = Tensor[Literal['N', 'N'], Real]
+        Matrix3: TypeAlias = Tensor[Literal[3, 3], Real]
+
+    Tensors have fixed or symbolic sizes and a uniform scalar data type.
+
+    Values of this type should not be constructed directly.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

fpy2-0.0.4/fpy2/analysis/__init__.py

@@ -0,0 +1,5 @@
+"""Program analyses for FPy programs"""
+
+from .define_use import DefineUse, DefineUseAnalysis, Definition, DefinitionCtx
+from .live_vars import LiveVars
+from .syntax_check import SyntaxCheck

fpy2-0.0.4/fpy2/analysis/define_use.py

@@ -0,0 +1,227 @@
+"""Definition use analysis for FPy ASTs"""
+
+from dataclasses import dataclass
+from typing import TypeAlias, Union
+
+from ..ast.fpyast import *
+from ..ast.visitor import DefaultVisitor
+from ..utils import default_repr
+
+Definition: TypeAlias = Argument | Stmt | CompExpr
+
+@default_repr
+class _DefineUnion:
+    """Union of possible definition sites."""
+    defs: set[Definition]
+
+    def __init__(self, defs: set[Definition]):
+        self.defs = set(defs)
+
+    def __eq__(self, other):
+        if not isinstance(other, _DefineUnion):
+            return NotImplemented
+        return self.defs == other.defs
+
+    def __hash__(self):
+        return hash(tuple(self.defs))
+
+    @staticmethod
+    def union(*defs_or_unions: Union[Definition, '_DefineUnion']):
+        """Create a union of definitions from a set of definitions or unions."""
+        defs: set[Definition] = set()
+        for item in defs_or_unions:
+            if isinstance(item, _DefineUnion):
+                defs.update(item.defs)
+            else:
+                defs.add(item)
+
+        if len(defs) == 0:
+            raise ValueError('Cannot create a union of an empty set of definitions')
+        elif len(defs) == 1:
+            return defs.pop()
+        else:
+            return _DefineUnion(defs)
+
+class DefinitionCtx(dict[NamedId, Definition | _DefineUnion]):
+    """Mapping from variable to its definition (or possible definitions)."""
+
+    def copy(self) -> 'DefinitionCtx':
+        """Returns a shallow copy of the context."""
+        return DefinitionCtx(self)
+
+    def mutated_in(self, other: 'DefinitionCtx') -> list[NamedId]:
+        """
+        Returns the set of variables that are defined in `self`
+        and mutated in `other`.
+        """
+        names: set[NamedId] = set()
+        for name in self.keys() & other.keys():
+            if self[name] != other[name]:
+                names.add(name)
+        return list(names)
+
+    def fresh_in(self, other: 'DefinitionCtx') -> set[NamedId]:
+        """
+        Returns the set of variables that are defined in `other`
+        but not in `self`.
+        """
+        return set(other.keys() - self.keys())
+
+
+@dataclass
+class DefineUseAnalysis:
+    """Result of definition-use analysis"""
+    defs: dict[NamedId, set[Definition]]
+    uses: dict[Definition, set[Var | IndexedAssign]]
+    stmts: dict[Stmt, tuple[DefinitionCtx, DefinitionCtx]]
+    blocks: dict[StmtBlock, tuple[DefinitionCtx, DefinitionCtx]]
+
+    @staticmethod
+    def default():
+        """Default analysis with empty definitions and uses"""
+        return DefineUseAnalysis({}, {}, {}, {})
+
+    @property
+    def names(self) -> set[NamedId]:
+        """Returns the set of all variable names in the analysis"""
+        return set(self.defs.keys())
+
+
+class _DefineUseInstance(DefaultVisitor):
+    """Per-IR instance of definition-use analysis"""
+    ast: FuncDef | StmtBlock
+    analysis: DefineUseAnalysis
+
+    def __init__(self, ast: FuncDef | StmtBlock):
+        self.ast = ast
+        self.analysis = DefineUseAnalysis.default()
+
+    def analyze(self):
+        match self.ast:
+            case FuncDef():
+                self._visit_function(self.ast, DefinitionCtx())
+            case StmtBlock():
+                self._visit_block(self.ast, DefinitionCtx())
+            case _:
+                raise RuntimeError(f'unreachable case: {self.ast}')
+        return self.analysis
+
+    def _add_def(self, name: NamedId, definition: Definition):
+        if name not in self.analysis.defs:
+            self.analysis.defs[name] = set()
+        self.analysis.defs[name].add(definition)
+        self.analysis.uses[definition] = set()
+
+    def _add_use(self, name: NamedId, use: Var | IndexedAssign, ctx: DefinitionCtx):
+        def_or_union = ctx[name]
+        if isinstance(def_or_union, _DefineUnion):
+            for def_ in def_or_union.defs:
+                self.analysis.uses[def_].add(use)
+        else:
+            self.analysis.uses[def_or_union].add(use)
+
+    def _visit_var(self, e: Var, ctx: DefinitionCtx):
+        if e.name not in ctx:
+            raise NotImplementedError(f'undefined variable {e.name}')
+        self._add_use(e.name, e, ctx)
+
+    def _visit_comp_expr(self, e: CompExpr, ctx: DefinitionCtx):
+        for iterable in e.iterables:
+            self._visit_expr(iterable, ctx)
+        ctx = ctx.copy()
+        for target in e.targets:
+            for name in target.names():
+                self._add_def(name, e)
+                ctx[name] = e
+        self._visit_expr(e.elt, ctx)
+
+    def _visit_assign(self, stmt: Assign, ctx: DefinitionCtx):
+        self._visit_expr(stmt.expr, ctx)
+        for var in stmt.binding.names():
+            self._add_def(var, stmt)
+            ctx[var] = stmt
+
+    def _visit_indexed_assign(self, stmt: IndexedAssign, ctx: DefinitionCtx):
+        self._add_use(stmt.var, stmt, ctx)
+        for slice in stmt.slices:
+            self._visit_expr(slice, ctx)
+        self._visit_expr(stmt.expr, ctx)
+
+    def _visit_if1(self, stmt: If1Stmt, ctx: DefinitionCtx):
+        self._visit_expr(stmt.cond, ctx)
+        body_ctx = self._visit_block(stmt.body, ctx.copy())
+        # merge contexts along both paths
+        # definitions cannot be introduced in the body
+        for var in ctx:
+            ctx[var] = _DefineUnion.union(ctx[var], body_ctx[var])
+
+    def _visit_if(self, stmt: IfStmt, ctx: DefinitionCtx):
+        self._visit_expr(stmt.cond, ctx)
+        ift_ctx = self._visit_block(stmt.ift, ctx.copy())
+        iff_ctx = self._visit_block(stmt.iff, ctx.copy())
+        # merge contexts along both paths
+        for var in ift_ctx.keys() & iff_ctx.keys():
+            ctx[var] = _DefineUnion.union(ift_ctx[var], iff_ctx[var])
+
+    def _visit_while(self, stmt: WhileStmt, ctx: DefinitionCtx):
+        self._visit_expr(stmt.cond, ctx)
+        body_ctx = self._visit_block(stmt.body, ctx.copy())
+        # merge contexts along both paths
+        # definitions cannot be introduced in the body
+        for var in ctx:
+            ctx[var] = _DefineUnion.union(ctx[var], body_ctx[var])
+
+    def _visit_for(self, stmt: ForStmt, ctx: DefinitionCtx):
+        self._visit_expr(stmt.iterable, ctx)
+        body_ctx = ctx.copy()
+        match stmt.target:
+            case NamedId():
+                self._add_def(stmt.target, stmt)
+                body_ctx[stmt.target] = stmt
+            case TupleBinding():
+                for var in stmt.target.names():
+                    self._add_def(var, stmt)
+                    body_ctx[var] = stmt
+
+        body_ctx = self._visit_block(stmt.body, body_ctx)
+        # merge contexts along both paths
+        # definitions cannot be introduced in the body
+        for var in ctx:
+            ctx[var] = _DefineUnion.union(ctx[var], body_ctx[var])
+
+    def _visit_statement(self, stmt: Stmt, ctx: DefinitionCtx):
+        ctx_in = ctx.copy()
+        super()._visit_statement(stmt, ctx)
+        self.analysis.stmts[stmt] = (ctx_in, ctx.copy())
+
+    def _visit_block(self, block: StmtBlock, ctx: DefinitionCtx):
+        ctx_in = ctx.copy()
+        for stmt in block.stmts:
+            self._visit_statement(stmt, ctx)
+        self.analysis.blocks[block] = (ctx_in, ctx.copy())
+        return ctx
+
+    def _visit_function(self, func: FuncDef, ctx: DefinitionCtx):
+        for arg in func.args:
+            if isinstance(arg.name, NamedId):
+                self._add_def(arg.name, arg)
+                ctx[arg.name] = arg
+        self._visit_block(func.body, ctx.copy())
+
+
+class DefineUse:
+    """
+    Definition-use analyzer for the FPy IR.
+
+    Computes definition-use chains for each variable.
+
+    name ---> definition ---> use1, use2, ...
+         ---> definition ---> use1, use2, ...
+         ...
+    """
+
+    @staticmethod
+    def analyze(ast: FuncDef | StmtBlock):
+        if not isinstance(ast, FuncDef | StmtBlock):
+            raise TypeError(f'Expected \'FuncDef\' or \'StmtBlock\', got {type(ast)} for {ast}')
+        return _DefineUseInstance(ast).analyze()

{fpy2-0.0.3/fpy2/ast → fpy2-0.0.4/fpy2/analysis}/live_vars.py

@@ -1,10 +1,10 @@
 """Live variable analysis for the FPy AST."""
 
-from . import *
+from ..ast import *
 
 _LiveSet = set[NamedId]
 
-class LiveVarsInstance(AstVisitor):
+class LiveVarsInstance(Visitor):
     """Single-use live variable analyzer"""
 
     ast: FuncDef | Expr
@@ -53,12 +53,12 @@ class LiveVarsInstance(AstVisitor):
         return self._visit_expr(e.arg, ctx)
 
     def _visit_binaryop(self, e: BinaryOp, ctx: None) -> _LiveSet:
-        return self._visit_expr(e.left, ctx) | self._visit_expr(e.right, ctx)
+        return self._visit_expr(e.first, ctx) | self._visit_expr(e.second, ctx)
 
     def _visit_ternaryop(self, e: TernaryOp, ctx: None) -> _LiveSet:
-        live0 = self._visit_expr(e.arg0, ctx)
-        live1 = self._visit_expr(e.arg1, ctx)
-        live2 = self._visit_expr(e.arg2, ctx)
+        live0 = self._visit_expr(e.first, ctx)
+        live1 = self._visit_expr(e.second, ctx)
+        live2 = self._visit_expr(e.third, ctx)
         return live0 | live1 | live2
 
     def _visit_naryop(self, e: NaryOp, ctx: None) -> _LiveSet:
@@ -87,7 +87,8 @@ class LiveVarsInstance(AstVisitor):
 
     def _visit_comp_expr(self, e: CompExpr, ctx: None) -> _LiveSet:
         live = self._visit_expr(e.elt, ctx)
-        live -= set([var for var in e.vars if isinstance(var, NamedId)])
+        for target in e.targets:
+            live |= target.names()
         for iterable in e.iterables:
             live |= self._visit_expr(iterable, ctx)
         return live
@@ -98,6 +99,13 @@ class LiveVarsInstance(AstVisitor):
             live |= self._visit_expr(s, ctx)
         return live
 
+    def _visit_tuple_set(self, e: TupleSet, ctx: None) -> _LiveSet:
+        live = self._visit_expr(e.array, ctx)
+        for s in e.slices:
+            live |= self._visit_expr(s, ctx)
+        live |= self._visit_expr(e.value, ctx)
+        return live
+
     def _visit_if_expr(self, e: IfExpr, ctx: None) -> _LiveSet:
         cond_live = self._visit_expr(e.cond, ctx)
         ift_live = self._visit_expr(e.ift, ctx)
@@ -111,20 +119,13 @@ class LiveVarsInstance(AstVisitor):
                 live.add(arg)
         return live
 
-    def _visit_simple_assign(self, stmt: SimpleAssign, live: _LiveSet) -> _LiveSet:
-        live = set(live)
-        if isinstance(stmt.var, NamedId):
-            live -= { stmt.var }
-        live |= self._visit_expr(stmt.expr, None)
-        return live
-
-    def _visit_tuple_unpack(self, stmt: TupleUnpack, live: _LiveSet) -> _LiveSet:
+    def _visit_assign(self, stmt: Assign, live: _LiveSet) -> _LiveSet:
         live = set(live)
         live -= stmt.binding.names()
         live |= self._visit_expr(stmt.expr, None)
         return live
 
-    def _visit_index_assign(self, stmt: IndexAssign, live: _LiveSet) -> _LiveSet:
+    def _visit_indexed_assign(self, stmt: IndexedAssign, live: _LiveSet) -> _LiveSet:
         live = set(live)
         live |= self._visit_expr(stmt.expr, None)
         for s in stmt.slices:
@@ -154,8 +155,11 @@ class LiveVarsInstance(AstVisitor):
     def _visit_for(self, stmt: ForStmt, live: _LiveSet) -> _LiveSet:
         live = set(live)
         live |= self._visit_block(stmt.body, live)
-        if isinstance(stmt.var, NamedId):
-            live -= { stmt.var }
+        match stmt.target:
+            case NamedId():
+                live -= { stmt.target }
+            case TupleBinding():
+                live -= stmt.target.names()
         live |= self._visit_expr(stmt.iterable, None)
         return live
 

{fpy2-0.0.3/fpy2/ast → fpy2-0.0.4/fpy2/analysis}/syntax_check.py

@@ -4,8 +4,8 @@ from typing import Optional, Self
 
 from ..utils import FPySyntaxError
 
-from .fpyast import *
-from .visitor import AstVisitor
+from ..ast.fpyast import *
+from ..ast.visitor import Visitor
 from .live_vars import LiveVars
 
 class _Env:
@@ -41,10 +41,10 @@ _Ctx = tuple[_Env, bool]
 2nd element: whether the current block is at the top-level.
 """
 
-class SyntaxCheckInstance(AstVisitor):
+class SyntaxCheckInstance(Visitor):
     """Single-use instance of syntax checking"""
     func: FuncDef
-    free_vars: set[str]
+    free_vars: set[NamedId]
     ignore_unknown: bool
     ignore_noreturn: bool
     allow_wildcard: bool
@@ -55,7 +55,7 @@ class SyntaxCheckInstance(AstVisitor):
     def __init__(
         self,
         func: FuncDef,
-        free_vars: set[str],
+        free_vars: set[NamedId],
         ignore_unknown: bool,
         ignore_noreturn: bool,
         allow_wildcard: bool
@@ -90,7 +90,7 @@ class SyntaxCheckInstance(AstVisitor):
                 raise FPySyntaxError(f'unbound variable `{name}`')
             if not env[name]:
                 raise FPySyntaxError(f'variable `{name}` not defined along all paths')
-        if name.base in self.free_vars:
+        if name in self.free_vars:
             self.free_var_args.add(name)
 
     def _visit_var(self, e: Var, ctx: _Ctx):
@@ -148,15 +148,15 @@ class SyntaxCheckInstance(AstVisitor):
 
     def _visit_binaryop(self, e: BinaryOp, ctx: _Ctx):
         env, _ = ctx
-        self._visit_expr(e.left, ctx)
-        self._visit_expr(e.right, ctx)
+        self._visit_expr(e.first, ctx)
+        self._visit_expr(e.second, ctx)
         return env
 
     def _visit_ternaryop(self, e: TernaryOp, ctx: _Ctx):
         env, _ = ctx
-        self._visit_expr(e.arg0, ctx)
-        self._visit_expr(e.arg1, ctx)
-        self._visit_expr(e.arg2, ctx)
+        self._visit_expr(e.first, ctx)
+        self._visit_expr(e.second, ctx)
+        self._visit_expr(e.third, ctx)
         return env
 
     def _visit_naryop(self, e: NaryOp, ctx: _Ctx):
@@ -173,7 +173,7 @@ class SyntaxCheckInstance(AstVisitor):
 
     def _visit_call(self, e: Call, ctx: _Ctx):
         env, _ = ctx
-        self._mark_use(NamedId(e.op), env, ignore_missing=self.ignore_unknown)
+        self._mark_use(NamedId(e.name), env, ignore_missing=self.ignore_unknown)
         for c in e.args:
             self._visit_expr(c, ctx)
         return env
@@ -188,9 +188,8 @@ class SyntaxCheckInstance(AstVisitor):
         env, _ = ctx
         for iterable in e.iterables:
             self._visit_expr(iterable, ctx)
-        for var in e.vars:
-            if isinstance(var, NamedId):
-                env = env.extend(var)
+        for target in e.targets:
+            env = self._visit_binding(target, env)
         self._visit_expr(e.elt, (env, False))
         return env
 
@@ -201,6 +200,14 @@ class SyntaxCheckInstance(AstVisitor):
             self._visit_expr(s, ctx)
         return env
 
+    def _visit_tuple_set(self, e: TupleSet, ctx: _Ctx):
+        env, _ = ctx
+        self._visit_expr(e.array, ctx)
+        for s in e.slices:
+            self._visit_expr(s, ctx)
+        self._visit_expr(e.value, ctx)
+        return env
+
     def _visit_if_expr(self, e: IfExpr, ctx: _Ctx):
         env, _ = ctx
         self._visit_expr(e.cond, ctx)
@@ -231,32 +238,29 @@ class SyntaxCheckInstance(AstVisitor):
                         if free not in self.free_vars:
                             raise FPySyntaxError('context is data-dependent')
 
-    def _visit_simple_assign(self, stmt: SimpleAssign, ctx: _Ctx):
-        env, _ = ctx
-        self._visit_expr(stmt.expr, ctx)
-        if isinstance(stmt.var, NamedId):
-            env = env.extend(stmt.var)
+    def _visit_binding(self, binding: Id | TupleBinding, env: _Env):
+        match binding:
+            case NamedId():
+                env = env.extend(binding)
+            case UnderscoreId():
+                pass
+            case TupleBinding():
+                env = self._visit_tuple_binding(binding, env)
+            case _:
+                raise RuntimeError('unreachable', binding)
         return env
 
-    def _visit_tuple_binding(self, binding: TupleBinding, ctx: _Ctx):
-        env, _ = ctx
+    def _visit_tuple_binding(self, binding: TupleBinding, env: _Env):
         for elt in binding.elts:
-            match elt:
-                case NamedId():
-                    env = env.extend(elt)
-                case TupleBinding():
-                    env = self._visit_tuple_binding(elt, ctx)
-                case UnderscoreId():
-                    pass
-                case _:
-                    raise NotImplementedError('unreachable', elt)
+            env = self._visit_binding(elt, env)
         return env
 
-    def _visit_tuple_unpack(self, stmt: TupleUnpack, ctx: _Ctx):
+    def _visit_assign(self, stmt: Assign, ctx: _Ctx):
+        env, _ = ctx
         self._visit_expr(stmt.expr, ctx)
-        return self._visit_tuple_binding(stmt.binding, ctx)
+        return self._visit_binding(stmt.binding, env)
 
-    def _visit_index_assign(self, stmt: IndexAssign, ctx: _Ctx):
+    def _visit_indexed_assign(self, stmt: IndexedAssign, ctx: _Ctx):
         env, _ = ctx
         self._mark_use(stmt.var, env)
         for s in stmt.slices:
@@ -286,8 +290,7 @@ class SyntaxCheckInstance(AstVisitor):
     def _visit_for(self, stmt: ForStmt, ctx: _Ctx):
         env, _ = ctx
         self._visit_expr(stmt.iterable, ctx)
-        if isinstance(stmt.var, NamedId):
-            env = env.extend(stmt.var)
+        env = self._visit_binding(stmt.target, env)
         body_env = self._visit_block(stmt.body, (env, False))
         return env.merge(body_env)
 
@@ -332,7 +335,7 @@ class SyntaxCheckInstance(AstVisitor):
     def _visit_function(self, func: FuncDef, ctx: _Ctx):
         env, _ = ctx
         for var in self.free_vars:
-            env = env.extend(NamedId(var))
+            env = env.extend(var)
         for arg in func.args:
             if isinstance(arg.name, NamedId):
                 env = env.extend(arg.name)
@@ -357,22 +360,25 @@ class SyntaxCheck:
     Rules enforced:
 
     Variables:
+
     - any variables must be defined before it is used;
 
     Return statements:
-     - all functions must have exactly one return statement,
-     - must be at the end of the function definiton;
+
+    - all functions must have exactly one return statement,
+    - must be at the end of the function definiton;
 
     If statements
-     - any variable must be defined along both branches when
-        used after the `if` statement
+
+    - any variable must be defined along both branches when
+      used after the `if` statement
     """
 
     @staticmethod
-    def analyze(
+    def check(
         func: FuncDef,
         *,
-        free_vars: Optional[set[str]] = None,
+        free_vars: Optional[set[NamedId]] = None,
         ignore_unknown: bool = False,
         ignore_noreturn: bool = False,
         allow_wildcard: bool = False
@@ -385,8 +391,9 @@ class SyntaxCheck:
 
         if not isinstance(func, FuncDef):
             raise TypeError(f'expected a Function, got {func}')
+
         if free_vars is None:
-            free_vars = set()
+            free_vars = set(func.free_vars)
 
         inst = SyntaxCheckInstance(func, free_vars, ignore_unknown, ignore_noreturn, allow_wildcard)
         return inst.analyze()

fpy2-0.0.4/fpy2/ast/__init__.py

@@ -0,0 +1,9 @@
+"""
+Abstract Syntax Tree (AST) for the FPy language.
+"""
+
+from .fpyast import *
+from .formatter import Formatter, BaseFormatter
+from .visitor import Visitor, DefaultVisitor, DefaultTransformVisitor
+
+set_default_formatter(Formatter())