fpy2 0.0.2__tar.gz → 0.0.3__tar.gz

fpy2-0.0.3/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: fpy2
+Version: 0.0.3
+Summary: An embedded DSL for numerical computing
+Author-email: Brett Saiki <bsaiki@cs.washington.edu>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bksaiki/fpy
+Project-URL: Issues, https://github.com/bksaiki/fpy/issues
+Project-URL: Documentation, https://fpy.readthedocs.io/
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: titanfp==0.1.1
+Requires-Dist: gmpy2==2.2
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: sphinx-rtd-theme; extra == "dev"
+Dynamic: license-file
+
+# FPy
+
+An embedded Python DSL for specifying and simulating numerical algorithms.
+
+Important lints:
+ - PyPI package: [fpy2](https://pypi.org/project/fpy2/)
+ - Documentation: [fpy2.readthedocs.io](https://fpy2.readthedocs.io/)
+ - GitHub: [fpy](https://github.com/bksaiki/fpy)
+
+## Installation
+
+Requirements:
+ - Python 3.11 or later
+
+The following instructions assume a `bash`-like shell.
+If you do not have a Python virtual environment,
+create one using
+```bash
+python3 -m venv .env/
+```
+and activate it using using
+```bash
+source .env/bin/activate
+```
+
+To install a _frozen_ instance of FPy, run:
+```bash
+pip install .
+```
+or with `make`, run
+```bash
+make install
+```
+Note that this will not install the necessary dependencies for
+development and installs a copy of the `fpy2` package.
+If you checkout a different commit or branch, you will
+need to reinstall FPy to overwrite the previous version.
+
+To uninstall FPy, run:
+```bash
+pip uninstall fpy2
+```
+
+## Development
+
+Developers of FPy should read this section since
+installing FPy is actually different.
+
+Requirements:
+ - Python 3.11 or later
+ - `make`
+
+### Installation
+
+If you do not have a Python virtual environment,
+create one using
+```bash
+python3 -m venv .env/
+```
+and activate it using using
+```bash
+source .env/bin/activate
+```
+To install an instance of FPy for development, run:
+```bash
+pip install -e .[dev]
+```
+or with `make`, run
+```bash
+make install-dev
+```
+
+### Testing
+
+There are a number of tests that can be run through
+the `Makefile` including
+```bash
+make lint
+```
+to ensure formatting and type safety;
+```bash
+make unittest
+```
+to run the unit tests;
+```bash
+make infratest
+```
+to run the infrastructure tests.

fpy2-0.0.3/README.md

@@ -0,0 +1,88 @@
+# FPy
+
+An embedded Python DSL for specifying and simulating numerical algorithms.
+
+Important lints:
+ - PyPI package: [fpy2](https://pypi.org/project/fpy2/)
+ - Documentation: [fpy2.readthedocs.io](https://fpy2.readthedocs.io/)
+ - GitHub: [fpy](https://github.com/bksaiki/fpy)
+
+## Installation
+
+Requirements:
+ - Python 3.11 or later
+
+The following instructions assume a `bash`-like shell.
+If you do not have a Python virtual environment,
+create one using
+```bash
+python3 -m venv .env/
+```
+and activate it using using
+```bash
+source .env/bin/activate
+```
+
+To install a _frozen_ instance of FPy, run:
+```bash
+pip install .
+```
+or with `make`, run
+```bash
+make install
+```
+Note that this will not install the necessary dependencies for
+development and installs a copy of the `fpy2` package.
+If you checkout a different commit or branch, you will
+need to reinstall FPy to overwrite the previous version.
+
+To uninstall FPy, run:
+```bash
+pip uninstall fpy2
+```
+
+## Development
+
+Developers of FPy should read this section since
+installing FPy is actually different.
+
+Requirements:
+ - Python 3.11 or later
+ - `make`
+
+### Installation
+
+If you do not have a Python virtual environment,
+create one using
+```bash
+python3 -m venv .env/
+```
+and activate it using using
+```bash
+source .env/bin/activate
+```
+To install an instance of FPy for development, run:
+```bash
+pip install -e .[dev]
+```
+or with `make`, run
+```bash
+make install-dev
+```
+
+### Testing
+
+There are a number of tests that can be run through
+the `Makefile` including
+```bash
+make lint
+```
+to ensure formatting and type safety;
+```bash
+make unittest
+```
+to run the unit tests;
+```bash
+make infratest
+```
+to run the infrastructure tests.

fpy2-0.0.3/fpy2/__init__.py

@@ -0,0 +1,73 @@
+"""
+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 (`MPContext`)
+ - multiprecision floatingpoint with subnormalization (`MPSContext`)
+ - bounded, multiprecision floating point (`MPBContext`)
+ - 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
+    ExtContext,
+    MPContext,
+    MPSContext,
+    MPBContext,
+    IEEEContext,
+    # rounding utilities
+    RoundingMode,
+    RoundingDirection, RM,
+    # encoding utilities
+    ExtNanKind,
+    # 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
+)
+
+from .fpc_context import FPCoreContext, NoSuchContextError
+
+from .decorator import fpy, pattern
+
+from .backend import (
+    Backend,
+    FPCoreCompiler,
+    FPYCompiler,
+)
+
+from .interpret import (
+    Interpreter,
+    PythonInterpreter,
+    RealInterpreter,
+    DefaultInterpreter,
+    set_default_interpreter,
+    get_default_interpreter,
+)
+
+from .function import Function
+
+from .utils import (
+    fraction,
+    digits_to_fraction as digits,
+    decnum_to_fraction as decnum,
+    hexnum_to_fraction as hexnum,
+)

fpy2-0.0.3/fpy2/analysis/__init__.py

@@ -0,0 +1,8 @@
+"""
+This module defines compiler analyses over FPy IR.
+"""
+
+from .define_use import DefineUse
+from .live_vars import LiveVars
+from .reaching_defs import ReachingDefs
+from .verify import VerifyIR

{fpy2-0.0.2/fpy2/passes → fpy2-0.0.3/fpy2/analysis}/define_use.py

@@ -4,11 +4,11 @@ from ..ir import *
 
 class _DefineUseInstance(DefaultVisitor):
     """Per-IR instance of definition-use analysis"""
-    func: FunctionDef
+    func: FuncDef
     uses: dict[NamedId, set[Var | PhiNode]]
     done: bool
 
-    def __init__(self, func: FunctionDef):
+    def __init__(self, func: FuncDef):
         self.func = func
         self.uses = {}
         self.done = False
@@ -33,17 +33,17 @@ class _DefineUseInstance(DefaultVisitor):
                 self.uses[var] = set()
         self._visit_expr(e.elt, ctx)
 
-    def _visit_var_assign(self, stmt: VarAssign, ctx: None):
+    def _visit_simple_assign(self, stmt: SimpleAssign, ctx: None):
         self._visit_expr(stmt.expr, ctx)
         if isinstance(stmt.var, NamedId):
             self.uses[stmt.var] = set()
 
-    def _visit_tuple_assign(self, stmt: TupleAssign, ctx: None):
+    def _visit_tuple_unpack(self, stmt: TupleUnpack, ctx: None):
         self._visit_expr(stmt.expr, ctx)
         for var in stmt.binding.names():
             self.uses[var] = set()
 
-    def _visit_if1_stmt(self, stmt: If1Stmt, ctx: None):
+    def _visit_if1(self, stmt: If1Stmt, ctx: None):
         self._visit_expr(stmt.cond, ctx)
         self._visit_block(stmt.body, ctx)
         for phi in stmt.phis:
@@ -51,7 +51,7 @@ class _DefineUseInstance(DefaultVisitor):
             self.uses[phi.lhs].add(phi)
             self.uses[phi.rhs].add(phi)
 
-    def _visit_if_stmt(self, stmt: IfStmt, ctx: None):
+    def _visit_if(self, stmt: IfStmt, ctx: None):
         self._visit_expr(stmt.cond, ctx)
         self._visit_block(stmt.ift, ctx)
         self._visit_block(stmt.iff, ctx)
@@ -60,7 +60,7 @@ class _DefineUseInstance(DefaultVisitor):
             self.uses[phi.lhs].add(phi)
             self.uses[phi.rhs].add(phi)
 
-    def _visit_while_stmt(self, stmt: WhileStmt, ctx: None):
+    def _visit_while(self, stmt: WhileStmt, ctx: None):
         for phi in stmt.phis:
             self.uses[phi.name] = set()
             self.uses[phi.lhs].add(phi)
@@ -69,7 +69,7 @@ class _DefineUseInstance(DefaultVisitor):
         for phi in stmt.phis:
             self.uses[phi.rhs].add(phi)
 
-    def _visit_for_stmt(self, stmt: ForStmt, ctx: None):
+    def _visit_for(self, stmt: ForStmt, ctx: None):
         self._visit_expr(stmt.iterable, ctx)
         if isinstance(stmt.var, NamedId):
             self.uses[stmt.var] = set()
@@ -80,7 +80,7 @@ class _DefineUseInstance(DefaultVisitor):
         for phi in stmt.phis:
             self.uses[phi.rhs].add(phi)
 
-    def _visit_function(self, func: FunctionDef, ctx):
+    def _visit_function(self, func: FuncDef, ctx):
         for arg in func.args:
             if isinstance(arg.name, NamedId):
                 self.uses[arg.name] = set()
@@ -101,5 +101,5 @@ class DefineUse:
     analysis_name = 'define_use'
 
     @staticmethod
-    def analyze(func: FunctionDef):
+    def analyze(func: FuncDef):
         return _DefineUseInstance(func).analyze()

fpy2-0.0.3/fpy2/analysis/live_vars.py

@@ -0,0 +1,225 @@
+"""Live variable analysis on the FPy IR"""
+
+from typing import TypeAlias
+
+from ..ir import *
+
+_RetType: TypeAlias = set[NamedId]
+
+class _LiveVars(ReduceVisitor):
+    """Single-instance of the live variable analysis."""
+    e: FuncDef | StmtBlock | Stmt | Expr
+
+    def __init__(self, e: FuncDef | StmtBlock | Stmt | Expr):
+        self.e = e
+
+    def analyze(self):
+        """Runs live-variable analysis on `self.e`."""
+        match self.e:
+            case FuncDef():
+                return self._visit_function(self.e, None)
+            case StmtBlock():
+                return self._visit_block(self.e, set())
+            case Stmt():
+                return self._visit_statement(self.e, set())
+            case Expr():
+                return self._visit_expr(self.e, None)
+            case _:
+                raise RuntimeError('unreachable')
+
+    def _visit_var(self, e: Var, ctx: None) -> _RetType:
+        return { e.name }
+
+    def _visit_bool(self, e: BoolVal, ctx: None) -> _RetType:
+        return set()
+
+    def _visit_foreign(self, e: ForeignVal, ctx: None) -> _RetType:
+        return set()
+
+    def _visit_decnum(self, e: Decnum, ctx: None) -> _RetType:
+        return set()
+
+    def _visit_hexnum(self, e: Hexnum, ctx: None) -> _RetType:
+        return set()
+
+    def _visit_integer(self, e: Integer, ctx: None) -> _RetType:
+        return set()
+
+    def _visit_rational(self, e: Rational, ctx: None) -> _RetType:
+        return set()
+
+    def _visit_constant(self, e: Constant, ctx: None) -> _RetType:
+        return set()
+
+    def _visit_digits(self, e: Digits, ctx: None) -> _RetType:
+        return set()
+
+    def _visit_unknown(self, e: UnknownCall, ctx: None) -> _RetType:
+        fvs = set()
+        for arg in e.children:
+            fvs.update(self._visit_expr(arg, ctx))
+        return fvs
+
+    def _visit_nary_expr(self, e: NaryExpr, ctx: None) -> _RetType:
+        fvs = set()
+        for arg in e.children:
+            fvs.update(self._visit_expr(arg, ctx))
+        return fvs
+
+    def _visit_compare(self, e: Compare, ctx: None) -> _RetType:
+        fvs = set()
+        for arg in e.children:
+            fvs.update(self._visit_expr(arg, ctx))
+        return fvs
+
+    def _visit_tuple_expr(self, e: TupleExpr, ctx: None) -> _RetType:
+        fvs = set()
+        for arg in e.children:
+            fvs.update(self._visit_expr(arg, ctx))
+        return fvs
+
+    def _visit_tuple_ref(self, e: TupleRef, ctx: None) -> _RetType:
+        fvs = self._visit_expr(e.value, ctx)
+        for arg in e.slices:
+            fvs.update(self._visit_expr(arg, ctx))
+        return fvs
+
+    def _visit_tuple_set(self, e: TupleSet, ctx: None) -> _RetType:
+        fvs = self._visit_expr(e.array, ctx)
+        for arg in e.slices:
+            fvs.update(self._visit_expr(arg, ctx))
+        fvs.update(self._visit_expr(e.value, ctx))
+        return fvs
+
+    def _visit_comp_expr(self, e: CompExpr, ctx: None) -> _RetType:
+        fvs = set()
+        for iterable in e.iterables:
+            fvs.update(self._visit_expr(iterable, ctx))
+        fvs.update(self._visit_expr(e.elt, ctx))
+        return fvs
+
+    def _visit_if_expr(self, e: IfExpr, ctx: None) -> _RetType:
+        fvs = self._visit_expr(e.cond, ctx)
+        fvs.update(self._visit_expr(e.ift, ctx))
+        fvs.update(self._visit_expr(e.iff, ctx))
+        return fvs
+
+    def _visit_simple_assign(self, stmt: SimpleAssign, ctx: _RetType) -> _RetType:
+        fvs = ctx | self._visit_expr(stmt.expr, None)
+        if isinstance(stmt.var, NamedId):
+            fvs.discard(stmt.var)
+        return fvs
+
+    def _visit_tuple_unpack(self, stmt: TupleUnpack, ctx: _RetType) -> _RetType:
+        fvs = ctx | self._visit_expr(stmt.expr, None)
+        for var in stmt.binding.names():
+            if isinstance(var, NamedId):
+                fvs.discard(var)
+        return fvs
+
+    def _visit_index_assign(self, stmt: IndexAssign, ctx: _RetType) -> _RetType:
+        fvs = ctx | self._visit_expr(stmt.expr, None)
+        for slice in stmt.slices:
+            fvs.update(self._visit_expr(slice, None))
+        fvs.add(stmt.var)
+        return fvs
+
+    def _visit_if1(self, stmt: If1Stmt, ctx: _RetType) -> _RetType:
+        ift_fvs = self._visit_block(stmt.body, ctx)
+        cond_fvs = self._visit_expr(stmt.cond, None)
+        return ctx | ift_fvs | cond_fvs
+
+    def _visit_if(self, stmt: IfStmt, ctx: _RetType) -> _RetType:
+        ift_fvs = self._visit_block(stmt.ift, ctx)
+        iff_fvs = self._visit_block(stmt.iff, ctx)
+        cond_fvs = self._visit_expr(stmt.cond, None)
+        return ift_fvs | iff_fvs | cond_fvs
+
+    def _visit_while(self, stmt: WhileStmt, ctx: _RetType) -> _RetType:
+        ctx = ctx | self._visit_block(stmt.body, ctx)
+        return ctx | self._visit_expr(stmt.cond, None)
+
+    def _visit_for(self, stmt: ForStmt, ctx: _RetType) -> _RetType:
+        body_fvs = self._visit_block(stmt.body, ctx)
+        if isinstance(stmt.var, NamedId):
+            body_fvs -= { stmt.var }
+        ctx = ctx | body_fvs
+        return ctx | self._visit_expr(stmt.iterable, None)
+
+    def _visit_foreign_attr(self, e: ForeignAttribute, ctx: None) -> _RetType:
+        return { e.name }
+
+    def _visit_context_expr(self, e: ContextExpr, ctx: None) -> _RetType:
+        match e.ctor:
+            case Var():
+                fvs = self._visit_var(e.ctor, None)
+            case ForeignAttribute():
+                fvs = self._visit_foreign_attr(e.ctor, None)
+            case _:
+                raise RuntimeError(f'unreachable {e.ctor}')
+
+        for arg in e.args:
+            match arg:
+                case ForeignAttribute():
+                    fvs |= self._visit_foreign_attr(arg, None)
+                case _:
+                    fvs |= self._visit_expr(arg, None)
+
+        return fvs
+
+    def _visit_context(self, stmt: ContextStmt, ctx: _RetType) -> _RetType:
+        body_fvs = self._visit_block(stmt.body, ctx)
+        if isinstance(stmt.name, NamedId):
+            body_fvs -= { stmt.name }
+        ctx = ctx | body_fvs
+        match stmt.ctx:
+            case Var():
+                ctx |= self._visit_var(stmt.ctx, None)
+            case ContextExpr():
+                ctx |= self._visit_context_expr(stmt.ctx, None)
+            case _:
+                raise RuntimeError(f'unreachable {stmt.ctx}')
+        return ctx
+
+    def _visit_assert(self, stmt: AssertStmt, ctx: _RetType) -> _RetType:
+        return ctx | self._visit_expr(stmt.test, None)
+
+    def _visit_effect(self, stmt: EffectStmt, ctx: _RetType) -> _RetType:
+        return ctx | self._visit_expr(stmt.expr, None)
+
+    def _visit_return(self, stmt: ReturnStmt, ctx: _RetType) -> _RetType:
+        return self._visit_expr(stmt.expr, None)
+
+    def _visit_block(self, block: StmtBlock, ctx: _RetType) -> _RetType:
+        fvs = ctx.copy()
+        for stmt in reversed(block.stmts):
+            if isinstance(stmt, ReturnStmt):
+                fvs = set()
+            fvs = self._visit_statement(stmt, fvs)
+        return fvs
+
+    def _visit_function(self, func: FuncDef, ctx: None) -> _RetType:
+        fvs = self._visit_block(func.body, set())
+        for arg in func.args:
+            if isinstance(arg, NamedId):
+                fvs.remove(arg)
+        return fvs
+
+    # overriden for typing hint
+    def _visit_expr(self, e: Expr, ctx: None) -> _RetType:
+        return super()._visit_expr(e, ctx)
+
+    # overriden for typing hint
+    def _visit_statement(self, e: Stmt, ctx: _RetType) -> _RetType:
+        return super()._visit_statement(e, ctx)
+
+
+class LiveVars:
+    """Live variable analysis for the FPy AST."""
+
+    @staticmethod
+    def analyze(e: FuncDef | StmtBlock | Stmt | Expr):
+        """Analyze the live variables in a function."""
+        if not isinstance(e, (FuncDef, StmtBlock, Stmt, Expr)):
+            raise TypeError(f'Expected FunctionDef, Block, Stmt or Expr, got {type(e)}')
+        return _LiveVars(e).analyze()

{fpy2-0.0.2/fpy2/passes → fpy2-0.0.3/fpy2/analysis}/reaching_defs.py

@@ -18,10 +18,10 @@ _RetType = tuple[set[NamedId], set[NamedId]]
 
 class _ReachingDefsInstance(DefaultVisitor):
     """Single-use instance of the reaching definitions analysis."""
-    func: FunctionDef
-    reaches: dict[Block, Reach]
+    func: FuncDef
+    reaches: dict[StmtBlock, Reach]
 
-    def __init__(self, func: FunctionDef):
+    def __init__(self, func: FuncDef):
         self.func = func
         self.reaches = {}
 
@@ -29,23 +29,23 @@ class _ReachingDefsInstance(DefaultVisitor):
         self._visit_function(self.func, None)
         return self.reaches
 
-    def _visit_var_assign(self, stmt: VarAssign, ctx: _StmtCtx) -> _RetType:
+    def _visit_simple_assign(self, stmt: SimpleAssign, ctx: _StmtCtx) -> _RetType:
         defs_in, kill_in = ctx
         defs_out = { *defs_in, stmt.var } if isinstance(stmt.var, NamedId) else defs_in
         kill_out = kill_in | (defs_in & { stmt.var })
         return defs_out, kill_out
 
-    def _visit_tuple_assign(self, stmt: TupleAssign, ctx: _StmtCtx) -> _RetType:
+    def _visit_tuple_unpack(self, stmt: TupleUnpack, ctx: _StmtCtx) -> _RetType:
         defs_in, kill_in = ctx
         gen = set(stmt.binding.names())
         defs_out = defs_in | gen
         kill_out = kill_in | (defs_in & gen)
         return defs_out, kill_out
 
-    def _visit_ref_assign(self, stmt: RefAssign, ctx: _StmtCtx) -> _RetType:
+    def _visit_index_assign(self, stmt: IndexAssign, ctx: _StmtCtx) -> _RetType:
         return ctx
 
-    def _visit_if1_stmt(self, stmt: If1Stmt, ctx: _StmtCtx) -> _RetType:
+    def _visit_if1(self, stmt: If1Stmt, ctx: _StmtCtx) -> _RetType:
         defs_in, kill_in = ctx
         _, block_kill = self._visit_block(stmt.body, defs_in)
 
@@ -53,7 +53,7 @@ class _ReachingDefsInstance(DefaultVisitor):
         kill_out = kill_in | (defs_in & block_kill)
         return defs_out, kill_out
 
-    def _visit_if_stmt(self, stmt: IfStmt, ctx: _StmtCtx) -> _RetType:
+    def _visit_if(self, stmt: IfStmt, ctx: _StmtCtx) -> _RetType:
         defs_in, kill_in = ctx
         ift_defs, ift_kill = self._visit_block(stmt.ift, defs_in)
         iff_defs, iff_kill = self._visit_block(stmt.iff, defs_in)
@@ -62,7 +62,7 @@ class _ReachingDefsInstance(DefaultVisitor):
         kill_out = kill_in | (defs_in & (ift_kill | iff_kill))
         return defs_out, kill_out
 
-    def _visit_while_stmt(self, stmt: WhileStmt, ctx: _StmtCtx) -> _RetType:
+    def _visit_while(self, stmt: WhileStmt, ctx: _StmtCtx) -> _RetType:
         defs_in, kill_in = ctx
         _, block_kill = self._visit_block(stmt.body, defs_in)
 
@@ -70,7 +70,7 @@ class _ReachingDefsInstance(DefaultVisitor):
         kill_out = kill_in | (defs_in & block_kill)
         return defs_out, kill_out
 
-    def _visit_for_stmt(self, stmt: ForStmt, ctx: _StmtCtx) -> _RetType:
+    def _visit_for(self, stmt: ForStmt, ctx: _StmtCtx) -> _RetType:
         defs_in, kill_in = ctx
         defs = { *defs_in, stmt.var } if isinstance(stmt.var, NamedId) else defs_in
         _, block_kill = self._visit_block(stmt.body, defs)
@@ -91,10 +91,13 @@ class _ReachingDefsInstance(DefaultVisitor):
     def _visit_assert(self, stmt: AssertStmt, ctx: _StmtCtx) -> _RetType:
         return ctx
 
-    def _visit_return(self, stmt: Return, ctx: _StmtCtx) -> _RetType:
+    def _visit_effect(self, stmt: EffectStmt, ctx: _StmtCtx) -> _RetType:
         return ctx
 
-    def _visit_block(self, block: Block, ctx: _BlockCtx):
+    def _visit_return(self, stmt: ReturnStmt, ctx: _StmtCtx) -> _RetType:
+        return ctx
+
+    def _visit_block(self, block: StmtBlock, ctx: _BlockCtx):
         reach_in = ctx.copy()
 
         defs: set[NamedId] = reach_in.copy()
@@ -106,7 +109,7 @@ class _ReachingDefsInstance(DefaultVisitor):
         self.reaches[block] = Reach(reach_in, reach_out, kill)
         return defs, kill
 
-    def _visit_function(self, func: FunctionDef, _: None):
+    def _visit_function(self, func: FuncDef, _: None):
         ctx: set[NamedId] = set()
         for arg in func.args:
             if isinstance(arg.name, NamedId):
@@ -125,5 +128,5 @@ class ReachingDefs:
     analysis_name = 'reaching_defs'
 
     @staticmethod
-    def analyze(func: FunctionDef) -> dict[Block, Reach]:
+    def analyze(func: FuncDef) -> dict[StmtBlock, Reach]:
         return _ReachingDefsInstance(func).analyze()