fpy2 0.2.2__tar.gz → 0.2.3__tar.gz

{fpy2-0.2.2 → fpy2-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fpy2
-Version: 0.2.2
+Version: 0.2.3
 Summary: An embedded DSL for numerical computing
 Author-email: Brett Saiki <bsaiki@cs.washington.edu>
 License-Expression: MIT

{fpy2-0.2.2 → fpy2-0.2.3}/fpy2/__init__.py

@@ -19,7 +19,17 @@ These number systems guarantee correct rounding via MPFR.
 # base library
 # standard library
 # submodules
-from . import analysis, ast, libraries, number, strategies, transform, types, utils
+from . import (
+    analysis,
+    ast,
+    libraries,
+    number,
+    rewrite,
+    strategies,
+    transform,
+    types,
+    utils,
+)
 
 # compiler
 from .backend import (
@@ -32,6 +42,7 @@ from .backend import (
 from .fpc_context import FPCoreContext, NoSuchContextError
 from .interpret import (
     BytecodeInterpreter,
+    Foreign,
     Interpreter,
     get_default_interpreter,
     set_default_interpreter,
@@ -40,6 +51,7 @@ from .libraries.base import *
 
 # module
 from .module import Module, ModuleCallGraph, ModuleEntry
+from .rewrite import Rewrite, find, find_all
 
 # runner
 from .runner import Runner, RunnerWorkerTask

{fpy2-0.2.2 → fpy2-0.2.3}/fpy2/analysis/__init__.py

@@ -1,6 +1,6 @@
 """Program analyses for FPy programs"""
 
-from .alias import Alias, AliasAnalysis, AllocSite
+from .alias import Alias, AliasAnalysis, AllocSite, Region, region_sizes
 from .array_size import (
     ArraySize,
     ArraySizeAnalysis,
@@ -35,6 +35,13 @@ from .reaching_defs import (
     ReachingDefs,
     ReachingDefsAnalysis,
 )
+from .storage_infer import (
+    StorageAnalysis,
+    StorageDomain,
+    StorageInfer,
+    StorageSelectionError,
+    of_bound,
+)
 from .syntax_check import FPySyntaxError, SyntaxCheck
 from .type_infer import TypeAnalysis, TypeInfer, TypeInferError
 from .value_class import (

{fpy2-0.2.2 → fpy2-0.2.3}/fpy2/analysis/alias.py

@@ -80,12 +80,14 @@ Limitations
 One *summary* store for the whole function, not one per program point, so it is
 flow-insensitive: ``ys = xs`` marks ``xs`` shared even if ``ys`` is dead
 immediately afterwards, and a container part counts as a referrer even if the
-container itself is never read.  Intraprocedural: a list handed to a call is
-shared outward, without asking whether the callee retains it.  Index-insensitive:
-``xs[0]`` and ``xs[1]`` are one part.  All three cost precision, not soundness.
+container itself is never read — except :attr:`AliasAnalysis.consumed_defs`,
+which buys back one flow-sensitive fact under narrow guards.  Intraprocedural: a
+list handed to a call is shared outward, without asking whether the callee
+retains it.  Index-insensitive: ``xs[0]`` and ``xs[1]`` are one part.  All three
+cost precision, not soundness.
 """
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Literal, overload
 
 from ..ast import (
@@ -112,16 +114,26 @@ from ..ast import (
     Range3,
     ReturnStmt,
     Snd,
+    Stmt,
+    StmtBlock,
     TupleBinding,
     TupleExpr,
     Var,
+    WhileStmt,
     Zip,
 )
 from ..function import Function
 from ..types import ListType, TupleType, Type
 from ..utils import Unionfind
+from .array_size import (
+    ArraySizeAnalysis,
+    ArraySizeBound,
+    ListSize,
+    TupleSize,
+    concrete_size,
+)
 from .define_use import DefineUse, DefineUseAnalysis
-from .reaching_defs import AssignDef, Definition, PhiDef, same_object_defs
+from .reaching_defs import AssignDef, Definition, same_object_defs
 from .type_infer import TypeAnalysis, TypeInfer
 
 if TYPE_CHECKING:
@@ -382,8 +394,18 @@ class _Regions:
 class AliasAnalysis:
     """Result of :class:`Alias`.
 
-    ``sites`` lists every list allocation the function performs, plus one per
-    list nested in each parameter's type.
+    ``written_regions``, ``slot_replaced`` and ``returned_levels`` are syntactic
+    facts keyed by region, for a consumer deciding how a list is held: whether a
+    reference may be ``const``, whether it may be a reference at all, and what
+    the ``return``s hand back together.
+
+    Attributes:
+        sites:            every list allocation, plus one per nested parameter list.
+        written_regions:  regions an ``xs[i] = e`` here stores into.
+        slot_replaced:    element regions an ``xss[i] = <list>`` replaces.
+        returned_levels:  regions the ``return``s hand back, by depth.
+        consumed_defs:    per region, definitions whose value *moves* into a
+                          container rather than coexisting with it.
     """
 
     sites: list[AllocSite]
@@ -391,6 +413,10 @@ class AliasAnalysis:
     _by_def: dict[Definition, Region]
     _by_expr: dict[Expr, Region]
     _site_region: dict[AllocSite, Region]
+    written_regions: set[Region] = field(default_factory=set)
+    slot_replaced: set[Region] = field(default_factory=set)
+    returned_levels: list[set[Region]] = field(default_factory=list)
+    consumed_defs: dict[Region, set[Definition]] = field(default_factory=dict)
 
     def region_of(self, d: Definition, depth: int = 0) -> Region | None:
         """What may be the same list as *d*, *depth* levels in.
@@ -442,6 +468,36 @@ class AliasAnalysis:
         names plus container slots."""
         return self._regions.referrers(region)
 
+    def consumed(self, region: Region) -> frozenset[Definition]:
+        """*region*'s definitions that hand their value to a container and are
+        never read again — see :attr:`consumed_defs`."""
+        return frozenset(self.consumed_defs.get(self._regions.find(region), ()))
+
+    def referrers_after_moves(self, region: Region) -> int:
+        """:meth:`referrers`, less the names the value *moves* out of.
+
+        Counting a consumed name makes ``xs = [n, n]; return (xs, 1.0)`` look
+        shared where the same program written inline does not.
+
+        A name is discounted only when *every* definition of it here is
+        consumed: :meth:`referrers` counts names, so one definition read twice
+        keeps the name a place however its siblings are used.
+
+        **A caller of this owes the move**, and only for a definition
+        :meth:`consumed` names.  Moving one it does not is a use-after-move.
+        """
+        root = self._regions.find(region)
+        consumed = self.consumed(root)
+        if not consumed:
+            return self.referrers(root)
+        by_name: dict[NamedId, list[Definition]] = {}
+        for d in self.defs_in(root):
+            by_name.setdefault(d.name, []).append(d)
+        gone = sum(
+            1 for ds in by_name.values() if all(d in consumed for d in ds)
+        )
+        return self.referrers(root) - gone
+
     def region_of_site(self, site: AllocSite) -> Region | None:
         """Which region *site*'s allocation lives in."""
         region = self._site_region.get(site)
@@ -493,7 +549,8 @@ class AliasAnalysis:
             self._regions.is_returned(region)
             and not self._regions.has_param_site(region)
             and not self._regions.is_shared_out(region)
-            and not self.is_shared(site)
+            # a name the returned container consumed is not a second holder
+            and self.referrers_after_moves(region) <= 1
         )
 
     def is_uniquely_owned(self, site: AllocSite) -> bool:
@@ -565,10 +622,21 @@ class _Builder(DefaultVisitor):
         self._merge_redefinitions()
         self._seed_params()
         self._visit_function(self.func, None)
-        return AliasAnalysis(
+        alias = AliasAnalysis(
             self.sites, self.regions, self.by_def, self._by_expr,
             self.site_region,
         )
+        # A second walk, because every fact asks `region_of` for where a place
+        # ends up and that is settled only once every merge has run.  Inside
+        # `run` rather than beside it: `transfers_ownership` reads them, so a
+        # result without them would answer a different question.
+        facts = _RegionFacts(alias, self.def_use)
+        facts._visit_function(self.func, None)
+        alias.written_regions = facts.written
+        alias.slot_replaced = facts.slot_replaced
+        alias.returned_levels = facts.returned_levels
+        alias.consumed_defs = facts.consumed
+        return alias
 
     # -- regions --------------------------------------------------------------
 
@@ -849,6 +917,224 @@ class _Builder(DefaultVisitor):
         super()._visit_return(stmt, ctx)
 
 
+class _RegionFacts(DefaultVisitor):
+    """Syntactic facts about regions, read off a *finished* region graph.
+
+    A second walk rather than part of :class:`_Builder`: each fact asks
+    ``region_of`` for the region a place ends up in, which is only settled once
+    every merge has run.
+    """
+
+    def __init__(self, alias: 'AliasAnalysis', def_use: DefineUseAnalysis):
+        self.alias = alias
+        self.def_use = def_use
+        self.written: set[Region] = set()
+        self.slot_replaced: set[Region] = set()
+        self.returned_levels: list[set[Region]] = []
+        self.consumed: dict[Region, set[Definition]] = {}
+        self._siblings: set[Stmt] = set()
+        self._repeats = 0
+        # Which phi consumed each operand.  A phi is not a use site, so
+        # sole-use would otherwise hold for a name whose value flows out of its
+        # branch -- and a merge inside one object's own class, a loop head
+        # threading a list through its fills, is not such a flow.
+        self._phi_of: dict[Definition, set[Definition]] = {}
+        for ps in def_use.phis.values():
+            for p in ps:
+                for i in (p.lhs, p.rhs):
+                    self._phi_of.setdefault(def_use.defs[i], set()).add(p)
+        for d in alias.all_defs():
+            if isinstance(d, AssignDef) and isinstance(d.site, IndexedAssign):
+                if (r := alias.region_of(d)) is not None:
+                    self.written.add(r)
+
+    def _visit_block(self, block: StmtBlock, ctx):
+        outer, self._siblings = self._siblings, set(block.stmts)
+        for stmt in block.stmts:
+            self._visit_statement(stmt, ctx)
+        self._siblings = outer
+
+    def _visit_while(self, stmt: WhileStmt, ctx):
+        # the condition re-runs every iteration, in the enclosing block
+        self._repeats += 1
+        self._visit_expr(stmt.cond, ctx)
+        self._repeats -= 1
+        self._visit_block(stmt.body, ctx)
+
+    def _visit_list_comp(self, e: ListComp, ctx):
+        for iterable in e.iterables:
+            self._visit_expr(iterable, ctx)
+        # the element runs once per item, and is an expression rather than a
+        # block, so the block guard alone does not see the repetition
+        self._repeats += 1
+        self._visit_expr(e.elt, ctx)
+        self._repeats -= 1
+
+    def _visit_tuple_expr(self, e: TupleExpr, ctx):
+        self._note_consumed(e.elts)
+        super()._visit_tuple_expr(e, ctx)
+
+    def _visit_list_expr(self, e: ListExpr, ctx):
+        self._note_consumed(e.elts)
+        super()._visit_list_expr(e, ctx)
+
+    def _same_object(self, d: Definition) -> set[Definition]:
+        """*d* and every definition denoting the same runtime object.
+
+        ``same_object_defs`` points from a phi to its operands and from an
+        ``xs[i] = e`` to what it mutated, so the closure reaches the whole chain
+        that filled one list.
+        """
+        seen: set[Definition] = set()
+        stack = [d]
+        while stack:
+            cur = stack.pop()
+            if cur in seen:
+                continue
+            seen.add(cur)
+            stack.extend(self.def_use.defs[i] for i in same_object_defs(cur))
+        return seen
+
+    def _moves_out(self, cls: set[Definition], e: Var) -> bool:
+        """Whether the object *cls* denotes is read only at *e*.
+
+        A write-through is not a second read: ``xs[i] = v`` uses the name, but
+        makes a definition ``same_object`` with the one it wrote through, so it
+        is already in *cls*.  The fill happens before the move.
+        """
+        for m in cls:
+            for u in self.def_use.uses.get(m, ()):
+                if u is e:
+                    continue
+                if isinstance(u, IndexedAssign) and isinstance(u.var, NamedId):
+                    fresh = self.def_use.find_def_from_site(u.var, u)
+                    if fresh in cls:
+                        continue
+                return False
+        return True
+
+    def _note_consumed(self, elts: 'tuple[Expr, ...]') -> None:
+        """Record each operand of a construction whose value *moves* into it.
+
+        Sound only where the construction provably runs once for that value, so
+        every way it could run again is refused: a use that re-executes
+        (``_repeats``), one whose definition is not a sibling statement, and one
+        whose value leaves through a phi outside the same object.
+
+        The unit is the *object*, not one definition of it: a list filled by a
+        loop reaches its consumer through a phi over the allocation and the
+        stores, and all three are recorded, since
+        :meth:`referrers_after_moves` drops a name only when every definition of
+        it is consumed.
+        """
+        if self._repeats:
+            return
+        for e in elts:
+            if not isinstance(e, Var):
+                continue
+            d = self.def_use.use_to_def.get(e)
+            if d is None:
+                continue
+            cls = self._same_object(d)
+            # the value has to be one this function made: a parameter is the
+            # caller's storage, and a class with no `Assign` allocated nothing
+            sites = [m.site for m in cls if isinstance(m, AssignDef)]
+            allocs = [s for s in sites if isinstance(s, Assign)]
+            if not allocs or any(not isinstance(s, (Assign, IndexedAssign))
+                                 for s in sites):
+                continue
+            if not self._moves_out(cls, e):
+                continue
+            # a phi outside the class carries the value somewhere else; one
+            # inside it is the loop head threading this same list
+            if any(p not in cls
+                   for m in cls for p in self._phi_of.get(m, ())):
+                continue
+            if any(s not in self._siblings for s in allocs):
+                continue
+            if (r := self.alias.region_of(d)) is not None:
+                self.consumed.setdefault(r, set()).update(cls)
+
+    def _visit_indexed_assign(self, stmt: IndexedAssign, ctx):
+        # Only a store of a *list* replaces a slot: a scalar write goes through
+        # the cell, leaving whatever region the element held intact.
+        if (
+            isinstance(stmt.var, NamedId)
+            and self.alias.region_of_expr(stmt.expr) is not None
+        ):
+            d = self.def_use.find_def_from_site(stmt.var, stmt)
+            if (r := self.alias.region_of(d, len(stmt.indices))) is not None:
+                self.slot_replaced.add(r)
+        super()._visit_indexed_assign(stmt, ctx)
+
+    def _visit_return(self, stmt: ReturnStmt, ctx):
+        depth = 0
+        while (r := self.alias.region_of_expr(stmt.expr, depth)) is not None:
+            while len(self.returned_levels) <= depth:
+                self.returned_levels.append(set())
+            self.returned_levels[depth].add(r)
+            depth += 1
+        super()._visit_return(stmt, ctx)
+
+
+_ALLOC_EXPRS = (
+    ListExpr, ListComp, Empty, ListSlice, Range1, Range2, Range3, Zip,
+    Enumerate, Call,
+)
+"""Expression forms that produce a list of their own.
+
+These seed :func:`region_sizes` in addition to the defs: a returned literal has
+a region but no def, and only its ``by_expr`` bound can size it.  Plain reads
+(``Var``, ``ListRef``) are left out -- they only mirror what a def contributed,
+and a lossy read-side bound must not poison a region a definition proved.
+"""
+
+
+def region_sizes(
+    alias: AliasAnalysis, array_size: ArraySizeAnalysis,
+) -> dict[Region, int | None]:
+    """One proven length per region, by meeting every contribution.
+
+    A region's storage must hold every value it is ever bound to, so the meet
+    poisons on any doubt: a def with no bound, a level the size analysis
+    answered ``None`` for, a symbolic size (a per-run variable, never a length
+    a fixed-length representation can spell), or two differing lengths all force ``None``.
+    Contributions walk each bound structurally against the region graph, so the
+    table is keyed by region exactly where a consumer reads it.
+
+    A free function because an :class:`AliasAnalysis` is usable without an
+    :class:`~fpy2.analysis.array_size.ArraySizeAnalysis`; only a caller wanting
+    lengths needs one.
+    """
+    sizes: dict[Region, int | None] = {}
+
+    def contribute(region: Region, k: int | None) -> None:
+        if region in sizes and sizes[region] != k:
+            sizes[region] = None
+        else:
+            sizes[region] = k
+
+    def seed(bound: ArraySizeBound, region: Region | None) -> None:
+        if region is None:
+            return
+        match bound:
+            case ListSize():
+                contribute(region, concrete_size(bound.size))
+                seed(bound.elt, alias.region_at(region))
+            case TupleSize():
+                for i, b in enumerate(bound.elts):
+                    seed(b, alias.region_field(region, i))
+            case None:
+                contribute(region, None)
+
+    for d in alias.all_defs():
+        seed(array_size.by_def.get(d), alias.region_of(d))
+    for e, bound in array_size.by_expr.items():
+        if isinstance(e, _ALLOC_EXPRS):
+            seed(bound, alias.region_of_expr(e))
+    return sizes
+
+
 class Alias:
     """Alias analysis for FPy programs."""
 

{fpy2-0.2.2 → fpy2-0.2.3}/fpy2/analysis/array_size.py

@@ -23,7 +23,7 @@ from typing import TypeAlias
 from ..ast.fpyast import *
 from ..ast.visitor import DefaultVisitor
 from ..function import Function
-from ..number import INTEGER, REAL, Float
+from ..number import INTEGER, REAL, Context, Float
 from ..types import ListType, TupleType, Type
 from ..utils import Gensym, NamedId, Unionfind
 from .context_use import ContextUse, ContextUseAnalysis, ContextUseSite
@@ -471,13 +471,9 @@ class _ArraySizeInferInstance(DefaultVisitor):
 
                 acc: ArraySizeBound = elt_ty
                 for arg in arg_rev:
-                    size_v = self._get_eval(arg)
-                    size = (
-                        int(INTEGER.round(size_v))
-                        if isinstance(size_v, Float | Fraction)
-                        else None
-                    )
-                    acc = ListSize(acc, size)
+                    # `_const_int`, not `_get_eval`: a dimension is commonly
+                    # `len(xs)`, which only the former folds
+                    acc = ListSize(acc, self._const_int(arg))
                 return acc
 
             case _:
@@ -579,6 +575,8 @@ class _ArraySizeInferInstance(DefaultVisitor):
         if c is not None:
             return (None, c)
 
+        # through a name: `t = i + 32; xs[i:t]` sizes like `xs[i:i+32]`
+        e = self.def_use.defining_expr(e)
         match e:
             case Add() if self._is_exact(e):
                 c = self._const_int(e.second)
@@ -604,27 +602,39 @@ class _ArraySizeInferInstance(DefaultVisitor):
     ) -> int | None:
         """``hi - lo`` as a compile-time constant, or ``None``.
 
-        Constant exactly when the two affine forms share a base — both
-        pure constants, or the same symbolic base (so it cancels).
+        Constant exactly when the two affine forms share a base — both pure
+        constants, or one variable with one *definition*.  Definitions, not
+        names: :meth:`_affine` follows a name to what it was assigned, so the two
+        bases may come from different program points, where a structural
+        comparison would match ``a + b`` against a later ``a + b`` that reads a
+        reassigned ``a``.
         """
         (lbase, loff), (hbase, hoff) = lo, hi
-        same_base = (
-            (lbase is None and hbase is None)
-            or (lbase is not None and hbase is not None
-                and lbase.is_equiv(hbase))
-        )
-        return hoff - loff if same_base else None
+        if lbase is None and hbase is None:
+            return hoff - loff
+        if not (isinstance(lbase, Var) and isinstance(hbase, Var)):
+            return None
+        ldef = self.def_use.find_def_from_use(lbase)
+        if ldef is not self.def_use.find_def_from_use(hbase):
+            return None
+        return hoff - loff
 
     def _const_int(self, e: Expr) -> int | None:
         """The integer value *e* statically evaluates to, or ``None``.
 
-        Covers partial-eval constants and the integer-valued list queries
-        ``len(xs)`` / ``size(xs, d)`` / ``dim(xs)`` when the queried size
-        is statically known (``dim`` always is — it's the nesting depth).
+        Covers partial-eval constants, the integer-valued list queries
+        ``len(xs)`` / ``size(xs, d)`` / ``dim(xs)`` when the queried size is
+        statically known (``dim`` always is — it's the nesting depth), and
+        ``+`` / ``-`` / ``*`` over those.  The arithmetic is what a lowered
+        multi-clause comprehension allocates with: ``fp.empty(len(xs) *
+        len(ys))``, whose size is otherwise unknown and whose list is then a
+        ``std::vector`` where the sizes are right there in the types.
         """
         val = self._get_eval(e)
         if isinstance(val, Float | Fraction):
             return int(INTEGER.round(val))
+        # through a name: a size query bound to one is still that query
+        e = self.def_use.defining_expr(e)
         match e:
             case Len():
                 bound = self.by_expr.get(e.arg)
@@ -645,8 +655,38 @@ class _ArraySizeInferInstance(DefaultVisitor):
                     bound = bound.elt
                 if isinstance(bound, ListSize) and isinstance(bound.size, int):
                     return bound.size
+            case Add() | Sub() | Mul():
+                lhs = self._const_int(e.first)
+                rhs = self._const_int(e.second)
+                if lhs is None or rhs is None:
+                    return None
+                match e:
+                    case Add():
+                        folded = lhs + rhs
+                    case Sub():
+                        folded = lhs - rhs
+                    case _:
+                        folded = lhs * rhs
+                return folded if self._holds_int(e, folded) else None
         return None
 
+    def _holds_int(self, e: ContextUseSite, value: int) -> bool:
+        """Whether *e*'s rounding leaves the integer *value* alone.
+
+        :meth:`_is_exact` asks whether the operation rounds *at all*, which
+        takes a ``REAL`` scope; an integer result needs only that the active
+        context represent it.  That is what carries a length through
+        ``integer_ctx``, which the loop rewrites wrap their index arithmetic in.
+
+        Checking the result alone is enough because the operands are
+        compile-time constants -- a static length, or a partial-eval value --
+        so nothing below *e* rounds.
+        """
+        scope = self._ctx_use.use_to_scope.get(e)
+        if scope is None or not isinstance(scope.ctx, Context):
+            return False
+        return scope.ctx.representable_under(Float.from_int(value, ctx=INTEGER))
+
     @staticmethod
     def _list_depth(bound: ArraySizeBound) -> int:
         """Number of nested list dimensions in *bound* (== ``dim``)."""
@@ -853,8 +893,11 @@ class _ArraySizeInferInstance(DefaultVisitor):
     def _len_size(self, e: Expr) -> ArraySize:
         """The size ``e`` constrains: the list's size for ``len(xs)``, the
         constant for an integer expression, else ``None`` (not relatable)."""
-        if isinstance(e, Len):
-            bound = self.by_expr.get(e.arg)
+        # through a name: `n = len(xs); assert n == 4` pins what
+        # `assert len(xs) == 4` does
+        src = self.def_use.defining_expr(e)
+        if isinstance(src, Len):
+            bound = self.by_expr.get(src.arg)
             return bound.size if isinstance(bound, ListSize) else None
         return self._const_int(e)
 

{fpy2-0.2.2 → fpy2-0.2.3}/fpy2/analysis/call_graph.py

@@ -47,13 +47,7 @@ class _CallCollector(DefaultVisitor):
 
     def _visit_call(self, e: Call, ctx: None):
         self.calls.append(e)
-        # ``DefaultVisitor._visit_call`` only walks positional args, so
-        # visit keyword-argument values explicitly — a call nested in a
-        # kwarg value (and any cycle through it) would otherwise be
-        # missed from the graph and the acyclicity guard.
         super()._visit_call(e, ctx)
-        for _, kwarg in e.kwargs:
-            self._visit_expr(kwarg, ctx)
 
     def collect(self, func: FuncDef) -> list[Call]:
         self.calls = []

{fpy2-0.2.2 → fpy2-0.2.3}/fpy2/analysis/context_use.py

@@ -16,7 +16,7 @@ from typing import TypeAlias
 from ..ast.fpyast import *
 from ..ast.visitor import DefaultVisitor
 from ..fpc_context import FPCoreContext
-from ..number import Context
+from ..number import REAL, Context
 from ..types import ContextParam
 from ..utils import Gensym, NamedId, default_repr
 from .define_use import DefineUse, DefineUseAnalysis
@@ -56,7 +56,15 @@ class ContextUseAnalysis:
     """all context scopes, ordered by introduction"""
 
     uses: dict[ContextScope, set[ContextUseSite]]
-    """mapping from context scope to use sites"""
+    """mapping from context scope to use sites.
+
+    A key here need not be in :attr:`scopes`: **E-Context** evaluates a
+    ``with``'s context expression under ``REAL``, so its uses get a ``REAL``
+    scope that introduces no ``with`` in the program.  Consumers keying scopes
+    by ``site`` (the cpp emitter, ``dead_code``) iterate :attr:`scopes` and so
+    never see it; consumers asking :meth:`find_scope_from_use` get the answer
+    the semantics give.
+    """
 
     use_to_scope: dict[ContextUseSite, ContextScope]
     """mapping from use site to context scope"""
@@ -148,25 +156,25 @@ class _ContextUseInstance(DefaultVisitor):
         self._record_use(e, scope)
 
     def _visit_call(self, e: Call, scope: ContextScope):
-        for arg in e.args:
-            self._visit_expr(arg, scope)
-        for _, kwarg in e.kwargs:
-            self._visit_expr(kwarg, scope)
+        super()._visit_call(e, scope)
         self._record_use(e, scope)
 
     # ------------------------------------------------------------------
     # Statement visitors
 
     def _visit_context(self, stmt: ContextStmt, scope: ContextScope):
-        # The context expression is evaluated under real arithmetic (not the
-        # enclosing floating-point context), so we do not visit it as a use
-        # of the enclosing context.  This is consistent with how
-        # partial_eval evaluates context expressions under REAL.
         # Resolve the context expression, falling back to a symbolic
         # variable when partial evaluation cannot determine the value.
         ctx = self._resolve_ctx_expr(stmt.ctx)
         # Create a fresh context scope for the body.
         new_scope = self._make_scope(stmt, ctx)
+        # **E-Context** evaluates the context expression under `REAL`, not the
+        # enclosing context, so its uses get a scope of their own.  Built after
+        # the body's, so a `with` whose context *is* `REAL` -- where the two
+        # compare equal -- merges into it rather than clearing it.
+        real_scope = ContextScope(stmt, REAL)
+        self.uses.setdefault(real_scope, set())
+        self._visit_expr(stmt.ctx, real_scope)
         self._visit_block(stmt.body, new_scope)
 
     # ------------------------------------------------------------------