Skip to main content

forge_lint/sol/med/
unsafe_oz_erc721_mint.rs

1use super::UnsafeOzErc721Mint;
2use crate::{
3    linter::{LateLintPass, LintContext},
4    sol::{
5        Severity, SolLint,
6        analysis::{
7            OPENZEPPELIN_ROOTS, arg_for_param, for_each_lhs_var, is_address_type, is_builtin,
8            is_literal_false, is_require_or_assert, loop_stmts, source_in_package, underlying_var,
9            unique, write_target,
10        },
11    },
12};
13use alloy_primitives::U256;
14use solar::{
15    ast::{ElementaryType, LitKind, StateMutability, Visibility},
16    interface::{Span, kw},
17    sema::{
18        Gcx,
19        hir::{
20            self, BinOpKind, CallArgs, Expr, ExprKind, FunctionId, Hir, ItemId, Stmt, StmtKind,
21            TypeKind, VariableId, Visit,
22        },
23        ty::{TyFn, TyKind},
24    },
25};
26use std::{ops::ControlFlow, slice};
27
28declare_forge_lint!(
29    UNSAFE_OZ_ERC721_MINT,
30    Severity::Med,
31    "unsafe-oz-erc721-mint",
32    "`ERC721._mint` does not check that the recipient can receive the token; use `_safeMint`"
33);
34
35impl<'gcx> LateLintPass<'gcx> for UnsafeOzErc721Mint {
36    fn check_function(
37        &mut self,
38        ctx: &LintContext,
39        gcx: Gcx<'gcx>,
40        func: &'gcx hir::Function<'gcx>,
41    ) {
42        let cx = Cx { gcx };
43        // Only the canonical OZ `_safeMint` wrapper is exempt: it legitimately calls `_mint`
44        // next to its receiver check. A user-defined `_safeMint` override stays analyzed, since
45        // it can call `_mint` directly without any check.
46        if named(func, "_safeMint")
47            && func
48                .contract
49                .is_some_and(|id| is_canonical_erc721(gcx.hir.contract(id).name.as_str()))
50            && source_in_package(&gcx.hir, func.source, OPENZEPPELIN_ROOTS)
51        {
52            return;
53        }
54        // A user `_mint` override is part of the mint primitive itself: `super._mint` there is
55        // delegation (the capped/pausable pattern), and `_safeMint` there would re-enter the
56        // override through the virtual dispatch. A delegating override reports at its call
57        // sites instead, where `_safeMint` is the fix. The same holds for a helper such an
58        // override delegates through.
59        if (named(func, "_mint") && func.override_) || cx.is_override_delegation_helper(func) {
60            return;
61        }
62        // `ERC721._mint` credits the token without calling `onERC721Received`, so minting to a
63        // contract that cannot handle ERC721 tokens locks the token; `_safeMint` performs the
64        // check. Flag calls that resolve to a `_mint` declared in an ERC721 contract. The type
65        // checker's resolution already accounts for overload selection, override shadowing and
66        // `super._mint(...)`.
67        let Some(body) = &func.body else { return };
68        for (callee, _, span) in cx.calls(body.stmts) {
69            let helper = cx.is_override_delegation_helper(gcx.hir.function(callee));
70            if cx.unsafe_mint_target(callee, helper, &mut Vec::new()).is_some() {
71                ctx.emit(&UNSAFE_OZ_ERC721_MINT, span);
72            }
73        }
74    }
75}
76
77/// An unsafe mint target and whether every recursive hop preserves the recipient and token it
78/// receives. A callback guard needs both guarantees, while a code-less-recipient proof needs
79/// only the first.
80#[derive(Clone, Copy)]
81struct UnsafeMintTarget {
82    preserves_recipient: bool,
83    preserves_token: bool,
84    preserves_code_length: bool,
85}
86
87/// A resolved call: its target, arguments and span.
88type Call<'gcx> = (FunctionId, &'gcx CallArgs<'gcx>, Span);
89
90/// The analysis context.
91#[derive(Clone, Copy)]
92struct Cx<'gcx> {
93    gcx: Gcx<'gcx>,
94}
95
96impl<'gcx> Cx<'gcx> {
97    /// Whether an internal/private function is reached from a user `_mint` override of a
98    /// derived contract, making it part of the mint primitive rather than a call site.
99    fn is_override_delegation_helper(self, function: &'gcx hir::Function<'gcx>) -> bool {
100        if !is_internal(function) || (function.override_ && named(function, "_mint")) {
101            return false;
102        }
103        let Some(contract_id) = function.contract else { return false };
104        let Some(function_id) = self
105            .gcx
106            .hir
107            .contract(contract_id)
108            .all_functions()
109            .find(|&id| std::ptr::eq(self.gcx.hir.function(id), function))
110        else {
111            return false;
112        };
113        self.gcx.hir.contract_ids().any(|candidate| {
114            let candidate = self.gcx.hir.contract(candidate);
115            candidate.linearized_bases.contains(&contract_id)
116                && candidate.all_functions().any(|id| {
117                    let f = self.gcx.hir.function(id);
118                    f.override_
119                        && named(f, "_mint")
120                        && self.function_reaches(id, function_id, &mut Vec::new())
121                })
122        })
123    }
124
125    /// Whether `function_id` calls `target`, directly or through internal functions.
126    fn function_reaches(
127        self,
128        function_id: FunctionId,
129        target: FunctionId,
130        seen: &mut Vec<FunctionId>,
131    ) -> bool {
132        if seen.contains(&function_id) {
133            return false;
134        }
135        seen.push(function_id);
136        let Some(body) = self.gcx.hir.function(function_id).body else { return false };
137        self.calls(body.stmts).iter().any(|&(callee, ..)| {
138            callee == target
139                || (is_internal(self.gcx.hir.function(callee))
140                    && self.function_reaches(callee, target, seen))
141        })
142    }
143
144    /// Whether `function_id` is a `_mint` whose execution skips the receiver check: the
145    /// canonical OZ declaration (exact OZ contract name AND an OpenZeppelin source path, so a
146    /// local contract reusing a name like `ERC721Consecutive` stays out), or a user override
147    /// whose body calls a `_mint` that is itself unsafe (the capped/pausable pattern forwarding
148    /// through `super._mint`). An override whose successful paths prove the recipient code-less
149    /// or reject it after the delegation is a safe wrapper like canonical `_safeMint`. `seen`
150    /// cuts override cycles, which never reach the canonical declaration.
151    fn unsafe_mint_target(
152        self,
153        function_id: FunctionId,
154        helper: bool,
155        seen: &mut Vec<FunctionId>,
156    ) -> Option<UnsafeMintTarget> {
157        if seen.contains(&function_id) {
158            return None;
159        }
160        seen.push(function_id);
161        let function = self.gcx.hir.function(function_id);
162        let is_mint = named(function, "_mint");
163        if !(is_mint || (helper && is_internal(function))) {
164            return None;
165        }
166        let contract = self.gcx.hir.contract(function.contract?);
167        if contract.kind.is_library() {
168            return None;
169        }
170        let canonical = is_canonical_erc721(contract.name.as_str())
171            && source_in_package(&self.gcx.hir, function.source, OPENZEPPELIN_ROOTS);
172        if canonical && named(function, "_safeMint") {
173            return None;
174        }
175        // Most extensions (`ERC721Enumerable`, ...) inherit `_mint` rather than redeclare it, so
176        // resolution still lands here.
177        if canonical && is_mint {
178            return Some(UnsafeMintTarget {
179                preserves_recipient: true,
180                preserves_token: true,
181                preserves_code_length: true,
182            });
183        }
184        if !(function.override_ || helper) {
185            return None;
186        }
187        let body = function.body.as_ref()?;
188        // The minted recipient is the override's first address-typed parameter.
189        let recipient =
190            function.parameters.iter().copied().find(|&vid| is_address_type(&self.gcx.hir, vid));
191        let calls = self.calls(body.stmts);
192        // Each distinct callee is judged once, with its own copy of `seen`: a cycle is a property
193        // of one path, and two siblings sharing a transitive target would otherwise silence the
194        // second.
195        let mut unsafe_targets = Vec::new();
196        let mut unstable_code_targets = Vec::new();
197        let mut judged = Vec::new();
198        let (mut targets_preserve_recipient, mut targets_preserve_token) = (true, true);
199        for &(callee, ..) in &calls {
200            if judged.contains(&callee) {
201                continue;
202            }
203            judged.push(callee);
204            if let Some(target) = self.unsafe_mint_target(callee, true, &mut seen.clone()) {
205                unsafe_targets.push(callee);
206                if !target.preserves_code_length {
207                    unstable_code_targets.push(callee);
208                }
209                targets_preserve_recipient &= target.preserves_recipient;
210                targets_preserve_token &= target.preserves_token;
211            }
212        }
213        let delegations: Vec<_> =
214            calls.iter().filter(|(callee, ..)| unsafe_targets.contains(callee)).collect();
215        if delegations.is_empty() {
216            return None;
217        }
218        // A guard covers the recipient it names, and no other. The recipient is what every
219        // delegation binds to the callee's first parameter, the token what it binds to the
220        // second, as the canonical `_mint(address to, uint256 tokenId)` orders them.
221        let forwards = |index: usize, var: Option<VariableId>| {
222            var.is_some_and(|var| {
223                delegations.iter().all(|&&(callee, args, _)| {
224                    self.arg(callee, args, index).and_then(|expr| underlying_var(self.gcx, expr))
225                        == Some(var)
226                })
227            })
228        };
229        let only_to_recipient = forwards(0, recipient);
230        // The token every delegation credits, when they all name the same variable: the
231        // recipient may accept one token and refuse another, so a guard is only about the token
232        // it was asked about. A token that is not a plain variable, or a mutable state variable
233        // that an intervening call may move under the guard's feet, cannot be matched.
234        let mut token = None;
235        let mut token_consistent = true;
236        for &&(callee, args, _) in &delegations {
237            let minted = self.arg(callee, args, 1).and_then(|expr| underlying_var(self.gcx, expr));
238            match minted.filter(|&minted| keeps_its_value(self.gcx, minted)) {
239                Some(minted) => {
240                    token_consistent &= token.is_none_or(|token| token == minted);
241                    token = Some(minted);
242                }
243                None => token_consistent = false,
244            }
245        }
246        // Modifier expansion may supply a code-less proof before the body or a callback guard
247        // after it. The body is still read in order because reassigning the recipient or token
248        // can make either guard name a different value from the delegation.
249        let guarded = |recipient, token, seed| {
250            let mut walk = self.modifier_coverage_at_body(function, recipient, token, seed);
251            let mut walker = GuardWalker {
252                cx: self,
253                recipient,
254                token,
255                delegations: &unsafe_targets,
256                unstable_code_delegations: &unstable_code_targets,
257                seen: &mut Vec::new(),
258            };
259            walker.walk(body.stmts, &mut walk);
260            !walk.failed && !walk.pending
261        };
262        // A proof that the recipient has no code is independent of the token being minted, so
263        // the recipient stands in both identity slots: a callback guard cannot type-check with
264        // an address as its token. This lets an address-only helper or modifier establish
265        // coverage and permits computed or remapped token arguments.
266        if only_to_recipient
267            && targets_preserve_recipient
268            && let Some(recipient) = recipient
269            && guarded(recipient, recipient, GuardCoverage::None)
270        {
271            return None;
272        }
273        if only_to_recipient
274            && token_consistent
275            && targets_preserve_recipient
276            && targets_preserve_token
277            && let Some(recipient) = recipient
278            && let Some(token) = token
279            && guarded(recipient, token, GuardCoverage::None)
280        {
281            return None;
282        }
283        // A guard in an outer override needs every intermediate override to preserve the
284        // identities it relies on: the recipient for a code-less proof, and both recipient and
285        // token for a callback. This summary is propagated only to callers; the current
286        // override's own guard above may legitimately check a remapped local value.
287        let preserves = |index: usize| {
288            function.parameters.get(index).is_some_and(|&var| {
289                !body.stmts.iter().any(|stmt| self.mutates_var(stmt, var))
290                    && !function.modifiers.iter().any(|modifier| {
291                        modifier.args.exprs().any(|arg| self.expr_mutates_var(arg, var))
292                    })
293                    && forwards(index, Some(var))
294            })
295        };
296        // A caller's code-less proof remains valid through this override only when no path can
297        // change account code before reaching a delegated mint.
298        let preserves_code_length = recipient
299            .is_some_and(|recipient| guarded(recipient, recipient, GuardCoverage::CodeLess));
300        Some(UnsafeMintTarget {
301            preserves_recipient: targets_preserve_recipient && preserves(0),
302            preserves_token: targets_preserve_token && preserves(1),
303            preserves_code_length,
304        })
305    }
306
307    /// Runs `stmt_matches`/`expr_matches` over a subtree and reports whether either held.
308    fn any_in_stmts(
309        self,
310        stmts: &'gcx [Stmt<'gcx>],
311        stmt_matches: impl FnMut(&'gcx Stmt<'gcx>) -> bool,
312        expr_matches: impl FnMut(&'gcx Expr<'gcx>) -> bool,
313    ) -> bool {
314        let mut finder = Finder { gcx: self.gcx, stmt_matches, expr_matches };
315        stmts.iter().any(|stmt| finder.visit_stmt(stmt).is_break())
316    }
317
318    fn any_in_expr(
319        self,
320        expr: &'gcx Expr<'gcx>,
321        expr_matches: impl FnMut(&'gcx Expr<'gcx>) -> bool,
322    ) -> bool {
323        Finder { gcx: self.gcx, stmt_matches: |_| false, expr_matches }.visit_expr(expr).is_break()
324    }
325
326    /// Every resolved call in a subtree, in source order.
327    fn calls(self, stmts: &'gcx [Stmt<'gcx>]) -> Vec<Call<'gcx>> {
328        let mut calls = Vec::new();
329        self.any_in_stmts(
330            stmts,
331            |_| false,
332            |expr| {
333                if let ExprKind::Call(_, args) = &expr.kind
334                    && let Some(function_id) = self.resolved_callee(expr)
335                {
336                    calls.push((function_id, args, expr.span));
337                }
338                false
339            },
340        );
341        calls
342    }
343
344    /// The function a call expression dispatches to, as the type checker resolved it.
345    fn resolved_callee(self, expr: &Expr<'_>) -> Option<FunctionId> {
346        let ExprKind::Call(callee, ..) = &expr.kind else { return None };
347        self.gcx.resolved_function(callee)
348    }
349
350    fn callee_fn(self, expr: &Expr<'_>) -> Option<&'gcx TyFn<'gcx>> {
351        let ExprKind::Call(callee, ..) = &expr.kind else { return None };
352        match self.gcx.type_of_expr(callee.peel_parens().id)?.kind {
353            TyKind::Fn(function_ty) => Some(function_ty),
354            _ => None,
355        }
356    }
357
358    /// The declaration a call executes in the current EVM frame. A public function called by
359    /// name is internal here, while `this.f()` and other external calls run in another frame
360    /// whose assembly `return` cannot bypass the caller's later statements.
361    fn resolved_internal_callee(self, expr: &Expr<'_>) -> Option<FunctionId> {
362        let function_ty = self.callee_fn(expr)?;
363        function_ty.is_internal().then_some(function_ty.function_id).flatten()
364    }
365
366    /// Whether a call dispatches through an internal function-pointer variable whose target is
367    /// not available from the callee type. Such a target may contain assembly that leaves the
368    /// frame, so exit analysis must treat the call conservatively.
369    fn is_unresolved_internal_pointer_call(self, expr: &Expr<'_>) -> bool {
370        let ExprKind::Call(callee, ..) = &expr.kind else { return false };
371        self.callee_fn(expr).is_some_and(|f| f.is_internal() && f.function_id.is_none())
372            && matches!(callee.peel_parens().kind, ExprKind::Ident(_))
373            && self.gcx.resolved_variable(callee).is_some()
374    }
375
376    /// The argument a call binds to the callee's parameter at `index`, positional or named.
377    fn arg(
378        self,
379        function_id: FunctionId,
380        args: &'gcx CallArgs<'gcx>,
381        index: usize,
382    ) -> Option<&'gcx Expr<'gcx>> {
383        let function = self.gcx.hir.function(function_id);
384        arg_for_param(self.gcx, function_id, *function.parameters.get(index)?, args)
385    }
386
387    /// Whether a resolved declaration is the ERC721 receiver hook: the exact name, the exact
388    /// `(address, address, uint256, bytes)` shape, and an externally callable declaration of a
389    /// non-library contract. A same-name function of an unrelated interface answers on a
390    /// different selector, and an attached library or free function runs in the minting
391    /// contract without any external call.
392    fn is_receiver_hook(self, function_id: FunctionId) -> bool {
393        let function = self.gcx.hir.function(function_id);
394        let Some(contract) = function.contract else { return false };
395        let &[from, to, id, data] = function.parameters else { return false };
396        let kind = |vid: VariableId| &self.gcx.hir.variable(vid).ty.kind;
397        named(function, "onERC721Received")
398            && !self.gcx.hir.contract(contract).kind.is_library()
399            && matches!(function.visibility, Visibility::Public | Visibility::External)
400            && is_address_type(&self.gcx.hir, from)
401            && is_address_type(&self.gcx.hir, to)
402            && matches!(kind(id), TypeKind::Elementary(ElementaryType::UInt(_)))
403            && matches!(kind(data), TypeKind::Elementary(ElementaryType::Bytes))
404    }
405
406    /// Whether an expression is the accepting answer, `onERC721Received`'s selector: the
407    /// literal, a conversion of it, a `constant` holding it, or a `selector` member resolving to
408    /// the receiver hook itself. The member is resolved rather than matched by name: spelled on
409    /// a same-name function of another shape, `.selector` is a different value. An `immutable`
410    /// or a state variable is unknown here and does not exempt.
411    fn is_received_selector(self, expr: &Expr<'gcx>) -> bool {
412        let expr = expr.peel_parens();
413        match &expr.kind {
414            ExprKind::Lit(lit) => {
415                matches!(&lit.kind, LitKind::Number(value) if *value == U256::from(ERC721_RECEIVED))
416            }
417            ExprKind::Call(callee, args)
418                if matches!(callee.peel_parens().kind, ExprKind::Type(..)) =>
419            {
420                args.len() == 1
421                    && args.exprs().next().is_some_and(|inner| {
422                        self.selector_cast_preserves(expr, inner)
423                            && self.is_received_selector(inner)
424                    })
425            }
426            ExprKind::Member(base, member) => {
427                member.as_str() == "selector"
428                    && self.gcx.resolved_function(base).is_some_and(|id| self.is_receiver_hook(id))
429            }
430            // A constant is worth what it holds.
431            ExprKind::Ident(_) => self.gcx.resolved_variable(expr).is_some_and(|vid| {
432                let variable = self.gcx.hir.variable(vid);
433                variable.is_constant()
434                    && variable.initializer.is_some_and(|init| self.is_received_selector(init))
435            }),
436            _ => false,
437        }
438    }
439
440    /// Whether a cast preserves the recognized selector's value and byte alignment. A recognized
441    /// integer is exactly the positive selector, so any integer width of at least 32 bits keeps
442    /// it. Fixed bytes are left-aligned while integers are right-aligned, so crossing between
443    /// them is only trusted at the four-byte boundary.
444    fn selector_cast_preserves(self, cast: &Expr<'_>, inner: &Expr<'_>) -> bool {
445        let encoding = |expr: &Expr<'_>| match self.gcx.type_of_expr(expr.peel_parens().id)?.kind {
446            TyKind::IntLiteral(..) => Some(SelectorEncoding::Literal),
447            TyKind::Elementary(ElementaryType::Int(size) | ElementaryType::UInt(size)) => {
448                Some(SelectorEncoding::Integer(size.bits()))
449            }
450            TyKind::Elementary(ElementaryType::FixedBytes(size)) => {
451                Some(SelectorEncoding::FixedBytes(size.bytes()))
452            }
453            _ => None,
454        };
455        matches!(
456            (encoding(inner), encoding(cast)),
457            (
458                Some(SelectorEncoding::Literal | SelectorEncoding::Integer(_)),
459                Some(SelectorEncoding::Integer(32..) | SelectorEncoding::FixedBytes(4))
460            ) | (Some(SelectorEncoding::FixedBytes(4)), Some(SelectorEncoding::Integer(32)))
461                | (
462                    Some(SelectorEncoding::FixedBytes(4..)),
463                    Some(SelectorEncoding::FixedBytes(4..))
464                )
465        )
466    }
467
468    /// Whether executing `stmt` always reverts, undoing everything the transaction did. Only a
469    /// revert counts, see [`Self::may_return`] for the escapes that leave the transaction
470    /// standing.
471    fn branch_always_reverts(self, stmt: &'gcx Stmt<'gcx>) -> bool {
472        match &stmt.kind {
473            StmtKind::Revert(_) => !self.may_return(stmt),
474            StmtKind::Expr(expr) => is_revert_call(self.gcx, expr) && !self.may_return(stmt),
475            // Read in order: a `revert` further down is only reached when nothing before it can
476            // leave the function on its own.
477            StmtKind::Block(block) | StmtKind::UncheckedBlock(block) => block
478                .stmts
479                .iter()
480                .find_map(|stmt| {
481                    self.branch_always_reverts(stmt)
482                        .then_some(true)
483                        .or_else(|| self.may_return(stmt).then_some(false))
484                })
485                .unwrap_or(false),
486            StmtKind::If(cond, then, Some(otherwise)) => {
487                !self.expr_contains_frame_ending_assembly(cond)
488                    && self.branch_always_reverts(then)
489                    && self.branch_always_reverts(otherwise)
490            }
491            _ => false,
492        }
493    }
494
495    /// Whether a statement may leave the function while keeping what the transaction already
496    /// did: a `return`, or the EVM `return`/`stop` an assembly block can hold. Only statements
497    /// that provably cannot leave answer no.
498    fn may_return(self, stmt: &'gcx Stmt<'gcx>) -> bool {
499        self.contains_frame_ending_assembly(slice::from_ref(stmt), &mut Vec::new())
500            || match &stmt.kind {
501                StmtKind::Block(block) | StmtKind::UncheckedBlock(block) => {
502                    block.stmts.iter().any(|stmt| self.may_return(stmt))
503                }
504                StmtKind::Loop(block, source) => {
505                    loop_stmts(*block, *source).any(|stmt| self.may_return(stmt))
506                }
507                StmtKind::If(_, then, otherwise) => {
508                    self.may_return(then) || otherwise.is_some_and(|stmt| self.may_return(stmt))
509                }
510                StmtKind::Return(_)
511                | StmtKind::AssemblyBlock(..)
512                | StmtKind::Try(_)
513                | StmtKind::Switch(_) => true,
514                _ => false,
515            }
516    }
517
518    /// Whether a subtree can reach an assembly block in the same EVM frame, directly or through
519    /// an internal call. An assembly `return` leaves the frame without running a later revert or
520    /// what an outer modifier holds after its placeholder. Every assembly block is treated as
521    /// capable of doing so.
522    fn contains_frame_ending_assembly(
523        self,
524        stmts: &'gcx [Stmt<'gcx>],
525        seen: &mut Vec<FunctionId>,
526    ) -> bool {
527        self.any_in_stmts(stmts, is_assembly, |expr| self.call_leaves_frame(expr, seen))
528    }
529
530    fn expr_contains_frame_ending_assembly(self, expr: &'gcx Expr<'gcx>) -> bool {
531        let mut seen = Vec::new();
532        self.any_in_expr(expr, |expr| self.call_leaves_frame(expr, &mut seen))
533    }
534
535    fn call_leaves_frame(self, expr: &Expr<'_>, seen: &mut Vec<FunctionId>) -> bool {
536        self.is_unresolved_internal_pointer_call(expr)
537            || self
538                .resolved_internal_callee(expr)
539                .is_some_and(|id| self.callable_contains_frame_ending_assembly(id, seen))
540    }
541
542    /// Whether a same-frame callable or one of its applied modifiers can reach assembly. The
543    /// recursion set is a path stack so independent calls are summarized independently.
544    fn callable_contains_frame_ending_assembly(
545        self,
546        function_id: FunctionId,
547        seen: &mut Vec<FunctionId>,
548    ) -> bool {
549        if seen.contains(&function_id) {
550            return false;
551        }
552        seen.push(function_id);
553        let function = self.gcx.hir.function(function_id);
554        let in_modifiers = function.modifiers.iter().any(|modifier| {
555            matches!(modifier.id, ItemId::Function(id)
556                if self.callable_contains_frame_ending_assembly(id, seen))
557        });
558        let in_body = function
559            .body
560            .as_ref()
561            .is_some_and(|body| self.contains_frame_ending_assembly(body.stmts, seen));
562        seen.pop();
563        in_modifiers || in_body
564    }
565
566    /// Whether a statement assigns to `var`: `var = x`, `var += x`, `var++`, `delete var`, or
567    /// `var` as a component of a tuple assignment. An assembly block is treated as an opaque
568    /// assignment, since it can rewrite Solidity locals outside the HIR expression tree.
569    /// Identity is by variable, not by value, so a guard that checked `var` says nothing once
570    /// `var` is reassigned.
571    fn mutates_var(self, stmt: &'gcx Stmt<'gcx>, var: VariableId) -> bool {
572        self.any_in_stmts(slice::from_ref(stmt), is_assembly, |expr| {
573            assigns_to(self.gcx, expr, var)
574        })
575    }
576
577    fn expr_mutates_var(self, expr: &'gcx Expr<'gcx>, var: VariableId) -> bool {
578        self.any_in_expr(expr, |expr| assigns_to(self.gcx, expr, var))
579    }
580
581    /// Whether a subtree may change the code installed at an account. Inline assembly is opaque
582    /// and may deploy code even when it contains no HIR call expression.
583    fn stmts_may_change_account_code(
584        self,
585        stmts: &'gcx [Stmt<'gcx>],
586        delegations: &[FunctionId],
587        unstable_code_delegations: &[FunctionId],
588        seen: &mut Vec<FunctionId>,
589    ) -> bool {
590        self.any_in_stmts(stmts, is_assembly, |expr| {
591            self.call_may_change_account_code(expr, delegations, unstable_code_delegations, seen)
592        })
593    }
594
595    fn expr_may_change_account_code(
596        self,
597        expr: &'gcx Expr<'gcx>,
598        delegations: &[FunctionId],
599        unstable_code_delegations: &[FunctionId],
600        seen: &mut Vec<FunctionId>,
601    ) -> bool {
602        self.any_in_expr(expr, |expr| {
603            self.call_may_change_account_code(expr, delegations, unstable_code_delegations, seen)
604        })
605    }
606
607    /// Whether a call may change the code installed at an account. Pure and view calls are
608    /// stable (external ones execute through `STATICCALL`), while nonpayable/payable calls and
609    /// contract creation can run `CREATE`/`CREATE2`. Calls to the delegated mint itself are
610    /// excluded unless it is recursively unstable: the code-length proof is needed precisely
611    /// until that call begins.
612    fn call_may_change_account_code(
613        self,
614        expr: &Expr<'_>,
615        delegations: &[FunctionId],
616        unstable_code_delegations: &[FunctionId],
617        seen: &mut Vec<FunctionId>,
618    ) -> bool {
619        let ExprKind::Call(callee, ..) = &expr.kind else { return false };
620        let (callee, _) = callee.split_call_options();
621        let resolved = self.resolved_callee(expr);
622        if resolved.is_some_and(|id| delegations.contains(&id))
623            && !resolved.is_some_and(|id| unstable_code_delegations.contains(&id))
624        {
625            return false;
626        }
627        if matches!(callee.kind, ExprKind::New(_)) {
628            return true;
629        }
630        if !self.callee_fn(expr).is_some_and(|f| {
631            matches!(f.state_mutability, StateMutability::NonPayable | StateMutability::Payable)
632        }) {
633            return false;
634        }
635        self.resolved_internal_callee(expr)
636            .filter(|&id| !self.gcx.hir.function(id).virtual_)
637            .is_none_or(|id| self.callable_may_change_account_code(id, seen))
638    }
639
640    /// Whether a statically known same-frame callable can create code, directly, through an
641    /// applied modifier, or through another internal call. Recursion cycles alone do not create
642    /// code; any opaque, virtual, or external state-changing call reached remains conservative.
643    fn callable_may_change_account_code(
644        self,
645        function_id: FunctionId,
646        seen: &mut Vec<FunctionId>,
647    ) -> bool {
648        if seen.contains(&function_id) {
649            return false;
650        }
651        seen.push(function_id);
652        let function = self.gcx.hir.function(function_id);
653        let may_change = function.modifiers.iter().any(|modifier| {
654            modifier.args.exprs().any(|arg| self.expr_may_change_account_code(arg, &[], &[], seen))
655        }) || function.modifiers.iter().any(|modifier| {
656            matches!(modifier.id, ItemId::Function(id)
657                if self.callable_may_change_account_code(id, seen))
658        }) || function
659            .body
660            .as_ref()
661            .is_some_and(|body| self.stmts_may_change_account_code(body.stmts, &[], &[], seen));
662        seen.pop();
663        may_change
664    }
665
666    /// The callee parameters that receive the caller's recipient and token identities.
667    fn bound_guard_parameters(
668        self,
669        function_id: FunctionId,
670        args: &'gcx CallArgs<'gcx>,
671        recipient: VariableId,
672        token: VariableId,
673    ) -> Option<(VariableId, VariableId)> {
674        let parameters = self.gcx.hir.function(function_id).parameters;
675        let bound_to = |var| {
676            parameters
677                .iter()
678                .enumerate()
679                .find(|&(index, _)| {
680                    self.arg(function_id, args, index)
681                        .and_then(|expr| underlying_var(self.gcx, expr))
682                        == Some(var)
683                })
684                .map(|(_, &parameter)| parameter)
685        };
686        bound_to(recipient).zip(bound_to(token))
687    }
688
689    /// Guard coverage a callee's body establishes for the parameters the recipient and the token
690    /// landed on: the callee guards when a guard ran before any possible successful exit. `seen`
691    /// cuts recursion cycles.
692    fn body_guards(
693        self,
694        function_id: FunctionId,
695        recipient: VariableId,
696        token: VariableId,
697        seen: &mut Vec<FunctionId>,
698    ) -> GuardCoverage {
699        if seen.contains(&function_id) {
700            return GuardCoverage::None;
701        }
702        seen.push(function_id);
703        let function = self.gcx.hir.function(function_id);
704        // A `virtual` callee may be replaced by an override that drops the guard, and a helper
705        // carrying modifiers is not credited until their expansion is modeled: one may skip the
706        // placeholder and let the helper return without ever running its body. The caller
707        // relies on the values it passed in, so a body that mutates either bound parameter is
708        // rejected too.
709        let guarded = match &function.body {
710            Some(body)
711                if !function.virtual_
712                    && function.modifiers.is_empty()
713                    && !body.stmts.iter().any(|stmt| {
714                        self.mutates_var(stmt, recipient) || self.mutates_var(stmt, token)
715                    }) =>
716            {
717                let mut walk = GuardWalk::default();
718                let mut walker = GuardWalker {
719                    cx: self,
720                    recipient,
721                    token,
722                    delegations: &[],
723                    unstable_code_delegations: &[],
724                    seen,
725                };
726                walker.walk(body.stmts, &mut walk);
727                if walk.escaped {
728                    GuardCoverage::None
729                } else if walk.future_coverage == GuardCoverage::CodeLess {
730                    GuardCoverage::CodeLess
731                } else if walk.coverage == GuardCoverage::CodeLess {
732                    // The code-less observation can discharge a mint that preceded the helper,
733                    // but later work invalidated it for a mint after the helper. The mixed
734                    // marker is treated by callers as discharge-only, like a callback.
735                    GuardCoverage::CallbackOrCodeLess
736                } else {
737                    walk.coverage
738                }
739            }
740            _ => GuardCoverage::None,
741        };
742        seen.pop();
743        guarded
744    }
745
746    /// Coverage in effect when a function body starts after expanding its modifiers in
747    /// declaration order. Prefixes are walked in execution order so calls in an inner modifier
748    /// can retire an outer code-length snapshot. A proven tail guard is represented as stable
749    /// callback coverage while walking the body: it runs after the body and can revert every
750    /// mint the body made, unless assembly in the body or an inner modifier can bypass it.
751    fn modifier_coverage_at_body(
752        self,
753        function: &'gcx hir::Function<'gcx>,
754        recipient: VariableId,
755        token: VariableId,
756        seed: GuardCoverage,
757    ) -> GuardWalk {
758        let mut state = GuardWalk { coverage: seed, future_coverage: seed, ..GuardWalk::default() };
759        let body_bypass = function
760            .body
761            .as_ref()
762            .is_some_and(|body| self.contains_frame_ending_assembly(body.stmts, &mut Vec::new()));
763        let mut has_tail_guard = false;
764        for (index, modifier) in function.modifiers.iter().enumerate() {
765            if modifier.args.exprs().any(|arg| {
766                self.expr_mutates_var(arg, recipient) || self.expr_mutates_var(arg, token)
767            }) {
768                state.coverage = GuardCoverage::None;
769                state.future_coverage = GuardCoverage::None;
770                has_tail_guard = false;
771            }
772            state.retire_code_snapshots_if(|| {
773                modifier
774                    .args
775                    .exprs()
776                    .any(|arg| self.expr_may_change_account_code(arg, &[], &[], &mut Vec::new()))
777            });
778            let ItemId::Function(modifier_id) = modifier.id else { continue };
779            let Some(body) = &self.gcx.hir.function(modifier_id).body else { continue };
780            let Some((prefix, suffix)) = modifier_body_sides(body.stmts) else {
781                // Without a single top-level placeholder, the precise prefix is unknown. Still
782                // retire an inherited snapshot when any path through the modifier may change
783                // code.
784                state.retire_code_snapshots_if(|| {
785                    self.stmts_may_change_account_code(body.stmts, &[], &[], &mut Vec::new())
786                });
787                continue;
788            };
789            let prefix_may_change_code =
790                || self.stmts_may_change_account_code(prefix, &[], &[], &mut Vec::new());
791            let Some((modifier_recipient, modifier_token)) =
792                self.bound_guard_parameters(modifier_id, &modifier.args, recipient, token)
793            else {
794                state.retire_code_snapshots_if(prefix_may_change_code);
795                continue;
796            };
797            let parameters_unchanged = !body.stmts.iter().any(|stmt| {
798                self.mutates_var(stmt, modifier_recipient) || self.mutates_var(stmt, modifier_token)
799            });
800            let mut walker = GuardWalker {
801                cx: self,
802                recipient: modifier_recipient,
803                token: modifier_token,
804                delegations: &[],
805                unstable_code_delegations: &[],
806                seen: &mut Vec::new(),
807            };
808            if parameters_unchanged {
809                walker.walk(prefix, &mut state);
810            } else {
811                state.retire_code_snapshots_if(prefix_may_change_code);
812            }
813            let inner_modifier_bypass = function.modifiers[index + 1..].iter().any(|inner| {
814                matches!(inner.id, ItemId::Function(id)
815                    if self.callable_contains_frame_ending_assembly(id, &mut Vec::new()))
816            });
817            if parameters_unchanged && !body_bypass && !inner_modifier_bypass {
818                // The body has already minted when the suffix starts. Seed one pending
819                // delegation: a guard anywhere before a successful suffix exit clears it, while a
820                // call after that guard cannot make the earlier mint retroactively unsafe.
821                let mut suffix_walk = GuardWalk { pending: true, ..GuardWalk::default() };
822                walker.walk(suffix, &mut suffix_walk);
823                has_tail_guard |= !suffix_walk.failed && !suffix_walk.pending;
824            }
825        }
826        if has_tail_guard {
827            state.cover(GuardCoverage::Callback, true);
828        }
829        GuardWalk {
830            coverage: state.coverage,
831            future_coverage: state.future_coverage,
832            ..GuardWalk::default()
833        }
834    }
835}
836
837/// Breaks out of a subtree at the first statement or expression matching a predicate.
838struct Finder<'gcx, S, E> {
839    gcx: Gcx<'gcx>,
840    stmt_matches: S,
841    expr_matches: E,
842}
843
844impl<'gcx, S, E> Visit<'gcx> for Finder<'gcx, S, E>
845where
846    S: FnMut(&'gcx Stmt<'gcx>) -> bool,
847    E: FnMut(&'gcx Expr<'gcx>) -> bool,
848{
849    type BreakValue = ();
850
851    fn hir(&self) -> &'gcx Hir<'gcx> {
852        &self.gcx.hir
853    }
854
855    fn visit_stmt(&mut self, stmt: &'gcx Stmt<'gcx>) -> ControlFlow<()> {
856        if (self.stmt_matches)(stmt) { ControlFlow::Break(()) } else { self.walk_stmt(stmt) }
857    }
858
859    fn visit_expr(&mut self, expr: &'gcx Expr<'gcx>) -> ControlFlow<()> {
860        if (self.expr_matches)(expr) { ControlFlow::Break(()) } else { self.walk_expr(expr) }
861    }
862}
863
864/// How a path established that the recipient can receive the mint. Callback evidence remains
865/// valid when summarizing a guard helper, while a code-less proof must be retired once a call
866/// could deploy code at the recipient address. Whether the evidence can cover a future mint is
867/// tracked separately by [`GuardWalk::future_coverage`].
868#[derive(Clone, Copy, Default, PartialEq, Eq)]
869enum GuardCoverage {
870    #[default]
871    None,
872    Callback,
873    CodeLess,
874    CallbackOrCodeLess,
875}
876
877impl GuardCoverage {
878    fn is_covered(self) -> bool {
879        self != Self::None
880    }
881
882    const fn relies_on_code_length(self) -> bool {
883        matches!(self, Self::CodeLess | Self::CallbackOrCodeLess)
884    }
885
886    /// The coverage guaranteed after either branch. If one path relies on a code-less proof,
887    /// the merged proof does too and remains invalidatable by a later call.
888    const fn merge_paths(self, other: Self) -> Self {
889        match (self, other) {
890            (Self::None, _) | (_, Self::None) => Self::None,
891            (Self::Callback, Self::Callback) => Self::Callback,
892            (Self::CodeLess, Self::CodeLess) => Self::CodeLess,
893            _ => Self::CallbackOrCodeLess,
894        }
895    }
896
897    /// Coverage from guards that all execute. A callback check remains valid when a later call
898    /// invalidates a separate code-length observation.
899    const fn combine_guards(self, other: Self) -> Self {
900        match (self, other) {
901            (Self::Callback, _) | (_, Self::Callback) => Self::Callback,
902            (Self::CallbackOrCodeLess, _) | (_, Self::CallbackOrCodeLess) => {
903                Self::CallbackOrCodeLess
904            }
905            (Self::CodeLess, _) | (_, Self::CodeLess) => Self::CodeLess,
906            _ => Self::None,
907        }
908    }
909}
910
911/// The straight-line reading of a body: `coverage` once a guard has run on the path, `pending`
912/// while a delegated mint has run with no guard before or after it yet, `failed` once a path
913/// may leave the function successfully with such a mint standing, `escaped` once one may leave
914/// before any guard ran.
915#[derive(Clone, Default)]
916struct GuardWalk {
917    /// The guards that have run on every path. This is used when summarizing a guard helper.
918    coverage: GuardCoverage,
919    /// Coverage that can satisfy a delegation encountered later. A code-less proof can precede
920    /// the mint; callback coverage can only appear here when a modifier tail guarantees that the
921    /// callback runs after the body.
922    future_coverage: GuardCoverage,
923    pending: bool,
924    failed: bool,
925    escaped: bool,
926}
927
928impl GuardWalk {
929    /// A guard ran: `coverage` is established, and also for later delegations when `future`.
930    const fn cover(&mut self, coverage: GuardCoverage, future: bool) {
931        self.coverage = self.coverage.combine_guards(coverage);
932        if future {
933            self.future_coverage = self.future_coverage.combine_guards(coverage);
934        }
935        self.pending = false;
936    }
937
938    /// The recipient or token was reassigned: every guard so far checked a value a later
939    /// delegation no longer credits, and a mint already pending cannot be covered by a guard to
940    /// come either.
941    const fn retire(&mut self) {
942        self.failed |= self.pending;
943        self.coverage = GuardCoverage::None;
944        self.future_coverage = GuardCoverage::None;
945    }
946
947    /// The path may leave the function successfully here.
948    fn escape(&mut self) {
949        self.failed |= self.pending;
950        self.escaped |= !self.coverage.is_covered();
951    }
952
953    /// Retires code-length snapshots when `may_change_code()` holds; a callback acknowledgement
954    /// is not a snapshot and stays. The check only runs when a snapshot exists.
955    fn retire_code_snapshots_if(&mut self, may_change_code: impl FnOnce() -> bool) {
956        let (coverage, future) =
957            (self.coverage.relies_on_code_length(), self.future_coverage.relies_on_code_length());
958        if (coverage || future) && may_change_code() {
959            if coverage {
960                self.coverage = GuardCoverage::None;
961            }
962            if future {
963                self.future_coverage = GuardCoverage::None;
964            }
965        }
966    }
967
968    /// The state after either of two branches: coverage holds only when every path checked,
969    /// while a pending or escaping path taints the whole.
970    const fn merge(self, other: Self) -> Self {
971        Self {
972            coverage: self.coverage.merge_paths(other.coverage),
973            future_coverage: self.future_coverage.merge_paths(other.future_coverage),
974            pending: self.pending || other.pending,
975            failed: self.failed || other.failed,
976            escaped: self.escaped || other.escaped,
977        }
978    }
979}
980
981/// Reads a body in statement order and judges the delegated mints against the guards for
982/// `recipient` and `token`. A code-less proof may cover a later delegation, but a callback must
983/// run after ownership is established to match `_safeMint`: the receiver can inspect `ownerOf`,
984/// balances, or reenter during the hook. Such a callback covers delegations still pending, the
985/// revert undoing them, unless a statement in between may leave the function successfully,
986/// keeping the unacknowledged token: `super._mint(to, id); if (id == 0) return; require(hook...)`
987/// walks out with token zero standing.
988///
989/// The recognized guard shapes are a closed set, because a hook call that merely appears inside
990/// a condition proves nothing about whether the revert depends on its answer. They are:
991/// `require`/`assert` on an acceptance condition, `if (hook != selector) <exits>`,
992/// `if (hook == selector) {} else <exits>`, and any of those reached through a function or
993/// modifier. A callback helper receives both identities, the way OpenZeppelin factors
994/// `_checkOnERC721Received` out of `_safeMint`; a code-less proof needs only the recipient.
995///
996/// Branches are read separately and merged. The branch a `to.code.length` test dedicates to
997/// accounts starts covered, an account always accepting the token. A loop body may run zero
998/// times, so nothing in one is credited, while the delegations and escapes it may hold still
999/// count.
1000///
1001/// Everything else reports, a `try` whose `catch` may swallow the refusal included, and so are
1002/// an answer stored in a local and a helper returning it as a `bool`. Following the value
1003/// across statements would take a dataflow analysis this detector does not run.
1004struct GuardWalker<'a, 'gcx> {
1005    cx: Cx<'gcx>,
1006    recipient: VariableId,
1007    token: VariableId,
1008    /// The callees that are unsafe mints, and those among them that may change account code.
1009    delegations: &'a [FunctionId],
1010    unstable_code_delegations: &'a [FunctionId],
1011    seen: &'a mut Vec<FunctionId>,
1012}
1013
1014impl<'gcx> GuardWalker<'_, 'gcx> {
1015    fn walk(&mut self, stmts: &'gcx [Stmt<'gcx>], walk: &mut GuardWalk) {
1016        let cx = self.cx;
1017        // Read in order: what a guard covers and what an exit walks out with depend on what
1018        // already ran.
1019        for stmt in stmts {
1020            let guard = match &stmt.kind {
1021                StmtKind::Expr(expr) => self.guard_expr_coverage(expr),
1022                _ => GuardCoverage::None,
1023            };
1024            match &stmt.kind {
1025                StmtKind::Block(block) | StmtKind::UncheckedBlock(block) => {
1026                    self.walk(block.stmts, walk);
1027                }
1028                StmtKind::Expr(expr) if guard.is_covered() => {
1029                    // A guard that also reassigns the recipient or the token cannot be trusted:
1030                    // evaluation order decides whether the hook read the value the mint credits.
1031                    // Nor can a guard that may leave the frame establish coverage: an assembly
1032                    // return in another argument can keep a pending mint before the builtin has
1033                    // a chance to revert.
1034                    if self.mutates(stmt) {
1035                        walk.retire();
1036                    } else if cx.may_return(stmt) {
1037                        walk.escape();
1038                    } else if guard.relies_on_code_length()
1039                        && self.guard_extra_args_may_change_account_code(expr)
1040                    {
1041                        if walk.future_coverage.relies_on_code_length() {
1042                            walk.future_coverage = GuardCoverage::None;
1043                        }
1044                    } else {
1045                        walk.cover(guard, guard == GuardCoverage::CodeLess);
1046                    }
1047                }
1048                StmtKind::If(cond, then, otherwise) => {
1049                    // The condition runs before either branch, so an assignment embedded in it,
1050                    // `if ((tokenId = tokenId + 1) > 0) {}`, retires coverage exactly as a bare
1051                    // assignment statement does, and prevents the comparison from covering.
1052                    let condition_mutates = cx.expr_mutates_var(cond, self.recipient)
1053                        || cx.expr_mutates_var(cond, self.token);
1054                    if condition_mutates {
1055                        walk.retire();
1056                    }
1057                    if walk.future_coverage.relies_on_code_length()
1058                        && self.may_change_account_code(slice::from_ref(stmt), Some(cond))
1059                    {
1060                        walk.future_coverage = GuardCoverage::None;
1061                    }
1062                    if cx.expr_contains_frame_ending_assembly(cond) {
1063                        walk.escape();
1064                    }
1065                    // The exiting branch must be the one a refusal takes, not the one an
1066                    // acceptance does. Continue reading the accepted branch from the covered
1067                    // state: it may still reassign the checked values before delegating.
1068                    let refusal_then = !condition_mutates
1069                        && self.is_hook_comparison(cond, BinOpKind::Ne)
1070                        && cx.branch_always_reverts(then);
1071                    let refusal_else = !condition_mutates
1072                        && self.is_hook_comparison(cond, BinOpKind::Eq)
1073                        && otherwise.is_some_and(|otherwise| cx.branch_always_reverts(otherwise));
1074                    if refusal_then || refusal_else {
1075                        walk.cover(GuardCoverage::Callback, false);
1076                        let accepted = if refusal_then { *otherwise } else { Some(*then) };
1077                        if let Some(accepted) = accepted {
1078                            self.walk(slice::from_ref(accepted), walk);
1079                        }
1080                        continue;
1081                    }
1082                    // Each branch is read on its own, from what already ran. The branch a
1083                    // `to.code.length` test dedicates to accounts starts covered with nothing
1084                    // pending: an account always accepts, so the mints already made are as
1085                    // satisfied on that path as the ones to come.
1086                    let mut then_walk = walk.clone();
1087                    let mut else_walk = walk.clone();
1088                    if self.is_code_length_test(cond, true) {
1089                        else_walk.cover(GuardCoverage::CodeLess, true);
1090                    } else if self.is_code_length_test(cond, false) {
1091                        then_walk.cover(GuardCoverage::CodeLess, true);
1092                    }
1093                    self.walk(slice::from_ref(then), &mut then_walk);
1094                    if let Some(otherwise) = otherwise {
1095                        self.walk(slice::from_ref(otherwise), &mut else_walk);
1096                    }
1097                    *walk = then_walk.merge(else_walk);
1098                }
1099                _ => {
1100                    // Reassignment runs first: an assignment inside a delegation's own arguments
1101                    // happens before the call.
1102                    if self.mutates(stmt) {
1103                        walk.retire();
1104                    }
1105                    // Unlike a callback acknowledgement, a code-length observation is only a
1106                    // snapshot. A later state-changing call can deploy code at that address, so
1107                    // it retires coverage for a subsequent delegation. A mint already discharged
1108                    // by the observation remains safe.
1109                    if walk.future_coverage.relies_on_code_length()
1110                        && self.may_change_account_code(slice::from_ref(stmt), None)
1111                    {
1112                        walk.future_coverage = GuardCoverage::None;
1113                    }
1114                    // An opaque statement: a delegation anywhere inside it mints, unchecked
1115                    // unless already covered, and a possible successful exit walks out with
1116                    // whatever is pending.
1117                    let delegations = self.delegations;
1118                    if !walk.future_coverage.is_covered()
1119                        && cx.any_in_stmts(
1120                            slice::from_ref(stmt),
1121                            |_| false,
1122                            |expr| {
1123                                cx.resolved_callee(expr).is_some_and(|id| delegations.contains(&id))
1124                            },
1125                        )
1126                    {
1127                        walk.pending = true;
1128                    }
1129                    if cx.may_return(stmt) {
1130                        walk.escape();
1131                    }
1132                }
1133            }
1134        }
1135    }
1136
1137    fn mutates(&self, stmt: &'gcx Stmt<'gcx>) -> bool {
1138        self.cx.mutates_var(stmt, self.recipient) || self.cx.mutates_var(stmt, self.token)
1139    }
1140
1141    /// [`Cx::stmts_may_change_account_code`] for the walked delegations, over a statement or
1142    /// only the given expression of it.
1143    fn may_change_account_code(
1144        &self,
1145        stmts: &'gcx [Stmt<'gcx>],
1146        expr: Option<&'gcx Expr<'gcx>>,
1147    ) -> bool {
1148        let (delegations, unstable) = (self.delegations, self.unstable_code_delegations);
1149        let mut seen = Vec::new();
1150        match expr {
1151            Some(expr) => {
1152                self.cx.expr_may_change_account_code(expr, delegations, unstable, &mut seen)
1153            }
1154            None => self.cx.stmts_may_change_account_code(stmts, delegations, unstable, &mut seen),
1155        }
1156    }
1157
1158    /// A statement expression that guards the recipient and the token: `require`/`assert` on an
1159    /// acceptance condition, or an internal call handing both to a helper that does. Only the
1160    /// condition is read: a hook call sitting in the revert message decides nothing. An external
1161    /// helper would ask from a different contract and cannot establish that the recipient
1162    /// accepts the minting contract's callback.
1163    fn guard_expr_coverage(&mut self, expr: &'gcx Expr<'gcx>) -> GuardCoverage {
1164        let expr = expr.peel_parens();
1165        let ExprKind::Call(callee, args) = &expr.kind else { return GuardCoverage::None };
1166        if is_require_or_assert(self.cx.gcx, callee) {
1167            return args
1168                .exprs()
1169                .next()
1170                .map_or(GuardCoverage::None, |cond| self.acceptance_coverage(cond));
1171        }
1172        let Some(function_id) = self.cx.resolved_internal_callee(expr) else {
1173            return GuardCoverage::None;
1174        };
1175        let Some((recipient, token)) =
1176            self.cx.bound_guard_parameters(function_id, args, self.recipient, self.token)
1177        else {
1178            return GuardCoverage::None;
1179        };
1180        self.cx.body_guards(function_id, recipient, token, self.seen)
1181    }
1182
1183    /// Whether a recognized `require`/`assert` has another argument that may change account
1184    /// code. The first argument is the closed-form acceptance condition itself; its receiver
1185    /// callback is part of the proof. Solidity does not guarantee that the other arguments run
1186    /// before the condition's code-length snapshot.
1187    fn guard_extra_args_may_change_account_code(&self, expr: &'gcx Expr<'gcx>) -> bool {
1188        let ExprKind::Call(callee, args) = &expr.peel_parens().kind else { return false };
1189        is_require_or_assert(self.cx.gcx, callee)
1190            && args.exprs().skip(1).any(|arg| self.may_change_account_code(&[], Some(arg)))
1191    }
1192
1193    /// The condition of a `require`/`assert` that passes only if the recipient can receive the
1194    /// token: the recipient is proven code-less, the hook comparison succeeds, or the short
1195    /// circuit `to.code.length == 0 || hook == sel` accepts either case.
1196    fn acceptance_coverage(&self, cond: &'gcx Expr<'gcx>) -> GuardCoverage {
1197        let cond = cond.peel_parens();
1198        if self.is_code_length_test(cond, false) {
1199            return GuardCoverage::CodeLess;
1200        }
1201        if self.is_hook_comparison(cond, BinOpKind::Eq) {
1202            return GuardCoverage::Callback;
1203        }
1204        let ExprKind::Binary(lhs, op, rhs) = &cond.kind else { return GuardCoverage::None };
1205        let accepts = |skip, check| {
1206            self.is_code_length_test(skip, false) && self.is_hook_comparison(check, BinOpKind::Eq)
1207        };
1208        if op.kind == BinOpKind::Or && (accepts(lhs, rhs) || accepts(rhs, lhs)) {
1209            GuardCoverage::CallbackOrCodeLess
1210        } else {
1211            GuardCoverage::None
1212        }
1213    }
1214
1215    /// `recipient.onERC721Received(..., token, ...)`: the hook, asked of the recipient itself and
1216    /// about the delegated token itself. An answer about a different id decides nothing for the
1217    /// minted one.
1218    fn is_hook_call_on(&self, expr: &'gcx Expr<'gcx>) -> bool {
1219        let expr = expr.peel_parens();
1220        let Some((callee, args, _)) = expr.as_call() else { return false };
1221        let ExprKind::Member(receiver, _) = &callee.peel_parens().kind else { return false };
1222        let Some(function_id) = self.cx.resolved_callee(expr) else { return false };
1223        self.cx.is_receiver_hook(function_id)
1224            && underlying_var(self.cx.gcx, receiver) == Some(self.recipient)
1225            && self.cx.arg(function_id, args, 2).and_then(|expr| underlying_var(self.cx.gcx, expr))
1226                == Some(self.token)
1227    }
1228
1229    /// `recipient.onERC721Received(...) <op> x`, and nothing else. The comparison must be the
1230    /// whole expression: in `to == trusted || hook(to) == selector` the hook never runs for
1231    /// `trusted`. The other operand must be able to hold the accepting answer, and must not be a
1232    /// hook call itself, which would compare the recipient against itself.
1233    fn is_hook_comparison(&self, expr: &'gcx Expr<'gcx>, want: BinOpKind) -> bool {
1234        let ExprKind::Binary(lhs, op, rhs) = &expr.peel_parens().kind else { return false };
1235        let compares = |hook, answer| {
1236            self.is_hook_call_on(hook)
1237                && !self.is_hook_call_on(answer)
1238                && self.cx.is_received_selector(answer)
1239        };
1240        op.kind == want && (compares(lhs, rhs) || compares(rhs, lhs))
1241    }
1242
1243    /// `recipient.code.length` compared against zero, for one polarity. Nothing else may ride
1244    /// along: in `to.code.length > 0 && id == 5` the second operand decides whether the branch
1245    /// runs.
1246    fn is_code_length_test(&self, expr: &'gcx Expr<'gcx>, has_code: bool) -> bool {
1247        let ExprKind::Binary(lhs, op, rhs) = &expr.peel_parens().kind else { return false };
1248        let is_code_length = |expr: &Expr<'_>| {
1249            let ExprKind::Member(code, length) = &expr.peel_parens().kind else { return false };
1250            let ExprKind::Member(base, member) = &code.peel_parens().kind else { return false };
1251            length.as_str() == "length"
1252                && member.as_str() == "code"
1253                && underlying_var(self.cx.gcx, base) == Some(self.recipient)
1254        };
1255        let literal = |expr: &Expr<'_>| match &expr.peel_parens().kind {
1256            ExprKind::Lit(lit) => match &lit.kind {
1257                LitKind::Number(value) => u8::try_from(*value).ok(),
1258                _ => None,
1259            },
1260            _ => None,
1261        };
1262        let (bound, flipped) = if is_code_length(lhs) {
1263            (literal(rhs), false)
1264        } else if is_code_length(rhs) {
1265            (literal(lhs), true)
1266        } else {
1267            return false;
1268        };
1269        let Some(bound) = bound else { return false };
1270        // `length > 0`, `length != 0` and `length >= 1` all say the recipient carries code;
1271        // `== 0`, `< 1` and `<= 0` all say it carries none. Each has a mirror with the operands
1272        // swapped.
1273        match (has_code, op.kind, flipped) {
1274            (true, BinOpKind::Ne, _)
1275            | (true, BinOpKind::Gt, false)
1276            | (true, BinOpKind::Lt, true)
1277            | (false, BinOpKind::Eq, _)
1278            | (false, BinOpKind::Le, false)
1279            | (false, BinOpKind::Ge, true) => bound == 0,
1280            (true, BinOpKind::Ge, false)
1281            | (true, BinOpKind::Le, true)
1282            | (false, BinOpKind::Lt, false)
1283            | (false, BinOpKind::Gt, true) => bound == 1,
1284            _ => false,
1285        }
1286    }
1287}
1288
1289/// The representation of a selector-sized constant at one conversion step.
1290#[derive(Clone, Copy)]
1291enum SelectorEncoding {
1292    Literal,
1293    Integer(u16),
1294    FixedBytes(u8),
1295}
1296
1297/// The ERC721 answer meaning the recipient accepts the token, `onERC721Received`'s selector.
1298const ERC721_RECEIVED: u64 = 0x150b_7a02;
1299
1300/// The OpenZeppelin contracts whose `_mint` skips the receiver check. `ERC721` and
1301/// `ERC721Upgradeable` declare the unchecked `_mint`; in the v4 line, `ERC721Consecutive` and
1302/// `ERC721ConsecutiveUpgradeable` override it with a construction guard that forwards to the
1303/// base through `super._mint`, still without a receiver check. In v5 the Consecutive extension
1304/// overrides `_update` instead, and the two extra names match nothing.
1305fn is_canonical_erc721(name: &str) -> bool {
1306    matches!(
1307        name,
1308        "ERC721" | "ERC721Upgradeable" | "ERC721Consecutive" | "ERC721ConsecutiveUpgradeable"
1309    )
1310}
1311
1312fn named(function: &hir::Function<'_>, name: &str) -> bool {
1313    function.name.is_some_and(|n| n.as_str() == name)
1314}
1315
1316const fn is_internal(function: &hir::Function<'_>) -> bool {
1317    matches!(function.visibility, Visibility::Internal | Visibility::Private)
1318}
1319
1320const fn is_assembly(stmt: &Stmt<'_>) -> bool {
1321    matches!(stmt.kind, StmtKind::AssemblyBlock(..))
1322}
1323
1324/// Whether the variable cannot change between the delegation and the callback guard. An
1325/// intervening call can reenter and mutate a state variable after the mint reads it but before
1326/// the guard does. A local, a parameter, a `constant` or an `immutable` cannot be moved that way.
1327fn keeps_its_value(gcx: Gcx<'_>, variable: VariableId) -> bool {
1328    let variable = gcx.hir.variable(variable);
1329    !variable.kind.is_state() || variable.mutability.is_some()
1330}
1331
1332/// Whether an expression writes `var`: `var = x`, `var += x`, `var++` or `delete var`, directly
1333/// or as one component of a tuple.
1334fn assigns_to(gcx: Gcx<'_>, expr: &Expr<'_>, var: VariableId) -> bool {
1335    let Some(target) = write_target(expr) else { return false };
1336    let mut hit = false;
1337    for_each_lhs_var(gcx, target, &mut |vid| hit |= vid == var);
1338    hit
1339}
1340
1341/// `revert(...)`, `require(false, ...)` and `assert(false)`.
1342fn is_revert_call(gcx: Gcx<'_>, expr: &Expr<'_>) -> bool {
1343    let ExprKind::Call(callee, args) = &expr.peel_parens().kind else { return false };
1344    is_builtin(gcx, callee, kw::Revert)
1345        || (is_require_or_assert(gcx, callee) && args.exprs().next().is_some_and(is_literal_false))
1346}
1347
1348/// The statements before and after a modifier's single top-level placeholder. More complicated
1349/// expansion shapes are left uncredited rather than guessing which paths execute the body.
1350fn modifier_body_sides<'gcx>(
1351    stmts: &'gcx [Stmt<'gcx>],
1352) -> Option<(&'gcx [Stmt<'gcx>], &'gcx [Stmt<'gcx>])> {
1353    let placeholders =
1354        stmts.iter().enumerate().filter(|(_, stmt)| matches!(stmt.kind, StmtKind::Placeholder));
1355    let index = unique(placeholders.map(|(index, _)| index))?;
1356    Some((&stmts[..index], &stmts[index + 1..]))
1357}