vj 0.2.0

//! Builds the [`VpiModel`] from the elaborated design (plan §1.4).
//!
//! The walk follows the LRM's object tree (IEEE 1800-2023 37.5-37.12, 37.85),
//! not slang's symbol tree: an instance array is an object whose elements are
//! its children, a loop generate is a generate-scope array of generate scopes,
//! and a conditional generate is one generate scope for the branch taken (the
//! branches not taken do not exist). It runs once, over a shared `&Design`,
//! before the run's evaluation session borrows the design exclusively.

use sv_lang::kinds::{StatementKind, SymbolKind};
use sv_lang::{
    ArgumentDirection, AssertionKind, ConstantRange, DefinitionKind, Design, FloatKind, NetKind,
    PredefinedIntegerKind, Statement, Symbol, SyntaxTree, Type, UnconnectedDrive, VariableLifetime,
};
use vj_sim::symid::{SymbolId, SymbolUid};

use super::consts;
use super::errors::VpiError;
use super::model::{
    ExprId, ExprNode, Obj, ObjId, ObjKind, OpMeta, Operand, ParamValue, Props, SigKey, TfInfo,
    VpiModel,
};
use super::value::{B4, Logic};

/// The most elements an unpacked array gets element objects for.
const MAX_ELEMENTS: usize = 1 << 16;

/// Source positions for `vpiLineNo`/`vpiDefLineNo`: line numbers come from the
/// syntax node a symbol was declared by.
struct Locator {
    trees: Vec<(SyntaxTree, Vec<usize>)>,
}

impl Locator {
    fn new(design: &Design) -> Self {
        let trees = design
            .syntax_trees()
            .into_iter()
            .map(|tree| {
                let text = tree.text();
                let starts = std::iter::once(0)
                    .chain(text.match_indices('\n').map(|(i, _)| i + 1))
                    .collect();
                (tree, starts)
            })
            .collect();
        Locator { trees }
    }

    /// The design's syntax trees.
    fn syntax_trees(&self) -> Vec<SyntaxTree> {
        self.trees.iter().map(|(t, _)| t.clone()).collect()
    }

    /// Whether the block statement `st` was written as `begin`/`fork`: slang
    /// also builds a block around a labeled statement and around a `foreach`
    /// (whose loop variables need a scope), which have other syntax. A block
    /// with no syntax node counts as written.
    fn is_begin_block(&self, st: &Statement<'_>) -> bool {
        use sv_lang::AstNode;
        self.trees
            .iter()
            .find_map(|(tree, _)| st.syntax(tree))
            .is_none_or(|n| sv_lang::nodes::BlockStatementSyntax::cast(n).is_some())
    }

    /// The 1-based line `sym` is declared on; 0 if it has no source (a
    /// synthesised symbol).
    fn line(&self, sym: &Symbol<'_>) -> i32 {
        for (tree, starts) in &self.trees {
            if let Some(node) = sym.syntax(tree) {
                let offset = node.byte_range().start;
                return starts.partition_point(|&s| s <= offset) as i32;
            }
        }
        0
    }

    /// The 1-based line statement `stmt` starts on; 0 if it has no source.
    ///
    /// A `Conditional`/`Case` recovered from an `Invalid` wrapper (a statically
    /// dead arm slang could not bind, LRM 12.4/12.5) has no syntax node, so its
    /// line comes from its source range instead: the offset is taken in the
    /// first tree whose text at that offset starts with the statement's keyword.
    fn stmt_line(&self, stmt: &Statement<'_>) -> i32 {
        for (tree, starts) in &self.trees {
            if let Some(node) = stmt.syntax(tree) {
                let offset = node.byte_range().start;
                return starts.partition_point(|&s| s <= offset) as i32;
            }
        }
        let range = stmt.source_range();
        if range.end.offset <= range.start.offset {
            return 0;
        }
        let offset = range.start.offset as usize;
        for (tree, starts) in &self.trees {
            let text = tree.text();
            let Some(rest) = text.get(offset..) else {
                continue;
            };
            if ["if", "unique", "priority", "case"]
                .iter()
                .any(|k| rest.starts_with(k))
            {
                return starts.partition_point(|&s| s <= offset) as i32;
            }
        }
        0
    }
}

/// The VPI class of an assertion statement, with its deferred/final flags
/// for an immediate one; `None` for any other statement (an `expect` is a
/// statement, not an assertion, 37.79).
fn assertion_kind(stmt: &Statement<'_>) -> Option<(ObjKind, bool, bool)> {
    match stmt.kind() {
        StatementKind::ConcurrentAssertion => Some((
            match stmt.assertion_kind()? {
                AssertionKind::Assert => ObjKind::Assert,
                AssertionKind::Assume => ObjKind::Assume,
                AssertionKind::CoverProperty | AssertionKind::CoverSequence => ObjKind::Cover,
                AssertionKind::Restrict => ObjKind::Restrict,
                AssertionKind::Expect => return None,
            },
            false,
            false,
        )),
        StatementKind::ImmediateAssertion => Some((
            match stmt.immediate_assertion_kind()? {
                AssertionKind::Assert => ObjKind::ImmediateAssert,
                AssertionKind::Assume => ObjKind::ImmediateAssume,
                _ => ObjKind::ImmediateCover,
            },
            stmt.is_deferred_assertion().unwrap_or(false),
            stmt.is_final_assertion().unwrap_or(false),
        )),
        _ => None,
    }
}

/// `default` or `global` of a clocking block's declaration, if either.
fn clocking_keyword(block: &Symbol<'_>, trees: &[SyntaxTree]) -> Option<sv_lang::kinds::TokenKind> {
    use sv_lang::kinds::SyntaxKind;
    for tree in trees {
        let Some(mut node) = block.syntax(tree) else {
            continue;
        };
        loop {
            if node.kind() == SyntaxKind::ClockingDeclaration {
                return <sv_lang::nodes::ClockingDeclarationSyntax as sv_lang::AstNode>::cast(node)
                    .and_then(|d| d.global_or_default())
                    .map(|t| t.kind());
            }
            match node.parent() {
                Some(p) => node = p,
                None => break,
            }
        }
    }
    None
}

/// The `vpiPosedge`/`vpiNegedge`/`vpiAnyEdge`/`vpiNoEdge` of a skew edge.
fn edge_const(edge: sv_lang::EdgeKind) -> i32 {
    let name = match edge {
        sv_lang::EdgeKind::PosEdge => "vpiPosedge",
        sv_lang::EdgeKind::NegEdge => "vpiNegedge",
        sv_lang::EdgeKind::BothEdges => "vpiAnyEdge",
        sv_lang::EdgeKind::None => "vpiNoEdge",
    };
    consts::value_of(name).expect("a vpi_user.h edge") as i32
}

/// The expression node of a formal's default value written `text` (a
/// literal of 5.7, 5.9 or 5.10; anything else is unsupported by name).
/// `text` split at its top-level commas (not inside brackets or quotes).
/// A `let` invocation written in the source (name and text).
#[derive(Clone)]
struct LetSite {
    name: String,
    text: String,
}

fn split_top_level(text: &str) -> Vec<String> {
    let (mut out, mut cur, mut depth, mut quoted) = (Vec::new(), String::new(), 0i32, false);
    for c in text.chars() {
        match c {
            '"' => quoted = !quoted,
            '(' | '[' | '{' if !quoted => depth += 1,
            ')' | ']' | '}' if !quoted => depth -= 1,
            ',' if !quoted && depth == 0 => {
                out.push(std::mem::take(&mut cur));
                continue;
            }
            _ => {}
        }
        cur.push(c);
    }
    if !cur.trim().is_empty() || !out.is_empty() {
        out.push(cur);
    }
    out
}

fn formal_default_node(text: &str) -> ExprNode {
    let cv = |name: &str| consts::value_of(name).expect("a vpi_user.h constant type") as i32;
    let konst = |value: Logic, signed: bool, ty: &str| ExprNode::Const {
        value,
        signed,
        const_type: cv(ty),
    };
    let bare: String = text.chars().filter(|c| *c != '_').collect();
    if let Some(inner) = bare.strip_prefix('"').and_then(|t| t.strip_suffix('"')) {
        return konst(
            Logic::from_string_val(inner.as_bytes(), 8 * inner.len().max(1) as u32),
            false,
            "vpiStringConst",
        );
    }
    if !bare.is_empty()
        && bare.chars().all(|c| c.is_ascii_digit())
        && let Some(l) = Logic::from_dec(&bare, 32)
    {
        return konst(l, true, "vpiDecConst");
    }
    if let Ok(r) = bare.parse::<f64>()
        && bare.contains(['.', 'e', 'E'])
    {
        return konst(Logic::from_u64(r.to_bits(), 64), false, "vpiRealConst");
    }
    // `[size]'[s]base digits` and the unbased unsized `'0 '1 'x 'z`.
    if let Some((size, rest)) = bare.split_once('\'') {
        // A non-empty size that is not a number (`a + 4'd1` splits at the
        // quote with `a + 4` before it) is an expression, not a literal.
        let size = if size.is_empty() {
            None
        } else if let Ok(n) = size.parse::<u32>() {
            Some(n)
        } else {
            return formal_default_unsupported(text);
        };
        let (signed, rest) = match rest.strip_prefix(['s', 'S']) {
            Some(r) => (true, r),
            None => (false, rest),
        };
        let lower = rest.to_ascii_lowercase();
        let mut it = lower.chars();
        let base = it.next();
        let digits: String = it.collect();
        if digits.is_empty()
            && size.is_none()
            && !signed
            && let Some(b) = base.filter(|b| matches!(b, '0' | '1' | 'x' | 'z'))
            && let Some(l) = Logic::from_radix(&b.to_string(), 1, 1)
        {
            return konst(l, false, "vpiBinaryConst");
        }
        let (bits, ty) = match base {
            Some('b') => (1, "vpiBinaryConst"),
            Some('o') => (3, "vpiOctConst"),
            Some('h') => (4, "vpiHexConst"),
            Some('d') => (0, "vpiDecConst"),
            _ => (-1i32, ""),
        };
        if bits >= 0 && !digits.is_empty() {
            let width = size.unwrap_or(32);
            let l = if bits == 0 {
                Logic::from_dec(&digits, width)
            } else {
                Logic::from_radix(&digits, bits as u32, width)
            };
            if let Some(l) = l {
                return konst(l, signed, ty);
            }
        }
    }
    formal_default_unsupported(text)
}

/// The loud refusal for a non-literal formal default. A default is bound by
/// slang only where the formal is instantiated and is never bound in the
/// declaration's own scope; binding the syntax there (with the other
/// formals as placeholders) needs a binder entry point that the sv-lang
/// bindings do not expose, so only literals are real expression objects.
fn formal_default_unsupported(text: &str) -> ExprNode {
    ExprNode::Unsupported(format!(
        "the default value `{text}` of a formal argument (only literals are modelled)"
    ))
}

/// `e` with the `Invalid` wrappers slang puts around an expression that
/// bound with an error removed (they nest). A `bound_body` is wrapped so
/// whenever a formal without a default is its untyped placeholder.
fn unwrap_invalid_expr<'d>(mut e: sv_lang::Expression<'d>) -> sv_lang::Expression<'d> {
    while e.kind() == sv_lang::kinds::ExpressionKind::Invalid
        && let Some(inner) = e.invalid_child()
    {
        e = inner;
    }
    e
}

/// A constant expression node for the literal value `c`.
fn const_node(c: &sv_lang::ConstantValue, kind: sv_lang::kinds::ExpressionKind) -> ExprNode {
    use sv_lang::kinds::ExpressionKind as K;
    let cv = |name: &str| consts::value_of(name).expect("a vpi_user.h constant type") as i32;
    if let Some(i) = c.as_integer() {
        return ExprNode::Const {
            value: logic_of(i),
            signed: i.is_signed(),
            // slang folds a string literal to its bit vector; it stays a
            // `vpiStringConst` (37.59).
            const_type: if kind == K::UnbasedUnsizedIntegerLiteral {
                cv("vpiBinaryConst")
            } else if kind == K::StringLiteral {
                cv("vpiStringConst")
            } else {
                cv("vpiDecConst")
            },
        };
    }
    if let Some(r) = c.as_f64() {
        return ExprNode::Const {
            value: Logic::from_u64(r.to_bits(), 64),
            signed: false,
            const_type: cv("vpiRealConst"),
        };
    }
    if let Some(t) = c.as_str() {
        return ExprNode::Const {
            value: Logic::from_string_val(t.as_bytes(), 8 * t.len().max(1) as u32),
            signed: false,
            const_type: cv("vpiStringConst"),
        };
    }
    ExprNode::Unsupported("a constant of an unsupported type".into())
}

/// The 4-state value of a slang integer.
fn logic_of(i: &sv_lang::SVInt) -> Logic {
    let width = i.bit_width();
    let mut l = Logic::zero(width);
    for k in 0..width {
        let b = i.bit(k as usize).map_or(B4::Zero, |b| {
            if b.is_unknown() {
                if b.logic_t_value() == sv_lang::Bit::z().logic_t_value() {
                    B4::Z
                } else {
                    B4::X
                }
            } else if b.logic_t_value() == 1 {
                B4::One
            } else {
                B4::Zero
            }
        });
        l.set(k, b);
    }
    l
}

/// Whether `e` contains a concatenation or replication slang built without
/// its operands (an untyped formal among them), however deeply nested.
fn has_empty_concat(e: &sv_lang::Expression<'_>) -> bool {
    use sv_lang::kinds::ExpressionKind as K;
    let own = match e.kind() {
        K::Concatenation => e.operands().is_empty(),
        K::Replication => e
            .replication_concat()
            .is_none_or(|c| c.operands().is_empty()),
        _ => false,
    };
    own || e
        .children_with_invalid()
        .iter()
        .filter_map(|c| c.as_expression())
        .any(|c| has_empty_concat(&unwrap_invalid_expr(c)))
}

/// The right-hand side of an assignment as written (37.64). slang binds
/// `a op= b` as `a = (lvalue-reference op b)`; the VPI right-hand side is
/// the `b` written in the source, and the lvalue reference (a second copy of
/// the left side, no object of its own) is dropped.
fn assign_rhs<'a>(e: &sv_lang::Expression<'a>) -> Option<sv_lang::Expression<'a>> {
    use sv_lang::kinds::ExpressionKind as K;
    // Strips implicit conversions (`a += b` widens the operation or its
    // operands to the left side's type, a shift does not).
    fn bare<'b>(mut x: sv_lang::Expression<'b>) -> sv_lang::Expression<'b> {
        while x.kind() == K::Conversion && x.conversion_is_implicit() != Some(false) {
            let Some(inner) = x.conversion_operand() else {
                break;
            };
            x = inner;
        }
        x
    }
    let r = e.right()?;
    if e.is_compound_assignment() == Some(true) {
        let ops = bare(r).operands();
        if let [l, b] = ops.as_slice()
            && bare(*l).kind() == K::LValueReference
        {
            return Some(*b);
        }
    }
    Some(r)
}

/// The `vpiOpType` of a compound assignment (`+=`, `<<=`, ...); `None` for a
/// plain `=`/`<=` (37.64).
fn compound_assign_op(e: &sv_lang::Expression<'_>) -> Option<i32> {
    if e.is_compound_assignment() == Some(true) {
        e.assignment_op().and_then(|b| {
            consts::value_of(match b {
                sv_lang::BinaryOp::Add => "vpiAddOp",
                sv_lang::BinaryOp::Subtract => "vpiSubOp",
                sv_lang::BinaryOp::Multiply => "vpiMultOp",
                sv_lang::BinaryOp::Divide => "vpiDivOp",
                sv_lang::BinaryOp::Mod => "vpiModOp",
                sv_lang::BinaryOp::BinaryAnd => "vpiBitAndOp",
                sv_lang::BinaryOp::BinaryOr => "vpiBitOrOp",
                sv_lang::BinaryOp::BinaryXor => "vpiBitXorOp",
                sv_lang::BinaryOp::LogicalShiftLeft => "vpiLShiftOp",
                sv_lang::BinaryOp::LogicalShiftRight => "vpiRShiftOp",
                sv_lang::BinaryOp::ArithmeticShiftLeft => "vpiArithLShiftOp",
                sv_lang::BinaryOp::ArithmeticShiftRight => "vpiArithRShiftOp",
                _ => "",
            })
            .map(|v| v as i32)
        })
    } else {
        None
    }
}

/// The `vpiOpType` of an operator expression, if it has one.
fn op_type_of(e: &sv_lang::Expression<'_>) -> Option<i32> {
    use sv_lang::kinds::ExpressionKind as K;
    use sv_lang::{BinaryOp as B, UnaryOp as U};
    let name = match e.kind() {
        K::ConditionalOp => "vpiConditionOp",
        K::MinTypMax => "vpiMinTypMaxOp",
        K::Concatenation => "vpiConcatOp",
        K::Replication => "vpiMultiConcatOp",
        K::Streaming => {
            if e.streaming_slice_size()? == 0 {
                "vpiStreamLROp"
            } else {
                "vpiStreamRLOp"
            }
        }
        K::UnaryOp => match e.unary_op()? {
            U::Plus => "vpiPlusOp",
            U::Minus => "vpiMinusOp",
            U::BitwiseNot => "vpiBitNegOp",
            U::BitwiseAnd => "vpiUnaryAndOp",
            U::BitwiseOr => "vpiUnaryOrOp",
            U::BitwiseXor => "vpiUnaryXorOp",
            U::BitwiseNand => "vpiUnaryNandOp",
            U::BitwiseNor => "vpiUnaryNorOp",
            U::BitwiseXnor => "vpiUnaryXNorOp",
            U::LogicalNot => "vpiNotOp",
            U::Preincrement => "vpiPreIncOp",
            U::Predecrement => "vpiPreDecOp",
            U::Postincrement => "vpiPostIncOp",
            U::Postdecrement => "vpiPostDecOp",
        },
        K::BinaryOp => match e.binary_op()? {
            B::Add => "vpiAddOp",
            B::Subtract => "vpiSubOp",
            B::Multiply => "vpiMultOp",
            B::Divide => "vpiDivOp",
            B::Mod => "vpiModOp",
            B::BinaryAnd => "vpiBitAndOp",
            B::BinaryOr => "vpiBitOrOp",
            B::BinaryXor => "vpiBitXorOp",
            B::BinaryXnor => "vpiBitXnorOp",
            B::Equality => "vpiEqOp",
            B::Inequality => "vpiNeqOp",
            B::CaseEquality => "vpiCaseEqOp",
            B::CaseInequality => "vpiCaseNeqOp",
            B::GreaterThanEqual => "vpiGeOp",
            B::GreaterThan => "vpiGtOp",
            B::LessThanEqual => "vpiLeOp",
            B::LessThan => "vpiLtOp",
            B::WildcardEquality => "vpiWildEqOp",
            B::WildcardInequality => "vpiWildNeqOp",
            B::LogicalAnd => "vpiLogAndOp",
            B::LogicalOr => "vpiLogOrOp",
            B::LogicalImplication => "vpiImpliesOp",
            B::LogicalShiftLeft => "vpiLShiftOp",
            B::LogicalShiftRight => "vpiRShiftOp",
            B::ArithmeticShiftLeft => "vpiArithLShiftOp",
            B::ArithmeticShiftRight => "vpiArithRShiftOp",
            B::Power => "vpiPowerOp",
            // `<->` has no vpiOpType in the 1800-2023 headers.
            _ => return None,
        },
        _ => return None,
    };
    consts::value_of(name).map(|v| v as i32)
}

/// Whether the instance array `array` holds primitive instances.
fn is_primitive_array(array: &Symbol<'_>) -> bool {
    array.instance_array_elements().next().is_some_and(|e| {
        e.kind() == SymbolKind::PrimitiveInstance
            || (e.kind() == SymbolKind::InstanceArray && is_primitive_array(&e))
    })
}

/// A primitive's VPI class, `vpiPrimType`, and how many of its `n`
/// terminals are outputs and inouts (they come first: inouts, then outputs,
/// then inputs).
fn prim_class(def: &str, n: usize, inst: &Symbol<'_>) -> (ObjKind, i32, usize, usize) {
    let c = |name: &str| consts::value_of(name).expect("a vpi_user.h primitive type") as i32;
    let gate = |t: &str, outs: usize| (ObjKind::Gate, c(t), outs, 0);
    let switch = |t: &str, outs: usize, inouts: usize| (ObjKind::Switch, c(t), outs, inouts);
    match def {
        "and" => gate("vpiAndPrim", 1),
        "nand" => gate("vpiNandPrim", 1),
        "or" => gate("vpiOrPrim", 1),
        "nor" => gate("vpiNorPrim", 1),
        "xor" => gate("vpiXorPrim", 1),
        "xnor" => gate("vpiXnorPrim", 1),
        "buf" => gate("vpiBufPrim", n.saturating_sub(1)),
        "not" => gate("vpiNotPrim", n.saturating_sub(1)),
        "bufif0" => gate("vpiBufif0Prim", 1),
        "bufif1" => gate("vpiBufif1Prim", 1),
        "notif0" => gate("vpiNotif0Prim", 1),
        "notif1" => gate("vpiNotif1Prim", 1),
        "pullup" => gate("vpiPullupPrim", n),
        "pulldown" => gate("vpiPulldownPrim", n),
        "nmos" => switch("vpiNmosPrim", 1, 0),
        "pmos" => switch("vpiPmosPrim", 1, 0),
        "cmos" => switch("vpiCmosPrim", 1, 0),
        "rnmos" => switch("vpiRnmosPrim", 1, 0),
        "rpmos" => switch("vpiRpmosPrim", 1, 0),
        "rcmos" => switch("vpiRcmosPrim", 1, 0),
        "tran" => switch("vpiTranPrim", 0, 2),
        "rtran" => switch("vpiRtranPrim", 0, 2),
        "tranif0" => switch("vpiTranif0Prim", 0, 2),
        "tranif1" => switch("vpiTranif1Prim", 0, 2),
        "rtranif0" => switch("vpiRtranif0Prim", 0, 2),
        "rtranif1" => switch("vpiRtranif1Prim", 0, 2),
        // A user-defined primitive: one output, then its inputs.
        _ => {
            let sequential = udp_definition(inst, def).is_some_and(|d| d.primitive_is_sequential());
            (
                ObjKind::Udp,
                c(if sequential {
                    "vpiSeqPrim"
                } else {
                    "vpiCombPrim"
                }),
                1,
                0,
            )
        }
    }
}

/// The user-defined primitive named `name` in `inst`'s design.
fn udp_definition<'d>(inst: &Symbol<'d>, name: &str) -> Option<Symbol<'d>> {
    let mut root = *inst;
    while let Some(p) = root.parent() {
        root = p;
    }
    root.members()
        .flat_map(|unit| unit.members().collect::<Vec<_>>())
        .find(|m| m.kind() == SymbolKind::Primitive && m.name() == name)
}

/// The `vpi*Drive` constant of a drive strength (`default_pull`: an
/// unspecified one is `pull` -- resistive switches, pullup/pulldown -- else
/// `strong`).
fn strength_const(s: Option<sv_lang::DriveStrength>, default_pull: bool) -> i32 {
    let name = match s {
        Some(sv_lang::DriveStrength::Supply) => "vpiSupplyDrive",
        Some(sv_lang::DriveStrength::Strong) => "vpiStrongDrive",
        Some(sv_lang::DriveStrength::Pull) => "vpiPullDrive",
        Some(sv_lang::DriveStrength::Weak) => "vpiWeakDrive",
        Some(sv_lang::DriveStrength::HighZ) => "vpiHighZ",
        None if default_pull => "vpiPullDrive",
        None => "vpiStrongDrive",
    };
    consts::value_of(name).expect("a vpi_user.h strength") as i32
}

/// The interface definition a virtual interface type names, and its modport
/// if it names one: read from slang's printed form of the type,
/// `[virtual ][interface ]NAME[#(params)][.modport]` (sv-lang exposes no
/// accessor for either).
fn vif_shape(ty: &Type<'_>) -> Option<VifShape> {
    let text = ty.to_sv_string();
    let mut rest = text.trim();
    for prefix in ["virtual ", "interface "] {
        rest = rest.strip_prefix(prefix).unwrap_or(rest).trim_start();
    }
    let end = rest.find(['#', '.', ' ']).unwrap_or(rest.len());
    let def = rest[..end].to_owned();
    let mut tail = &rest[end..];
    let mut params = Vec::new();
    if let Some(list) = tail.strip_prefix('#') {
        // `#(...)`, nested parentheses and all.
        let mut depth = 0usize;
        let mut close = None;
        let mut cuts = vec![1usize];
        for (i, c) in list.char_indices() {
            match c {
                '(' => depth += 1,
                ')' => {
                    depth = depth.checked_sub(1)?;
                    if depth == 0 {
                        close = Some(i);
                        break;
                    }
                }
                ',' if depth == 1 => cuts.push(i + 1),
                _ => {}
            }
        }
        let close = close?;
        cuts.push(close + 1);
        // slang prints each assignment as `NAME=VALUE`.
        for w in cuts.windows(2) {
            let item = list[w[0]..w[1] - 1].trim();
            if let Some((n, v)) = item.split_once('=') {
                params.push((n.trim().to_owned(), v.trim().to_owned()));
            }
        }
        tail = &list[close + 1..];
    }
    let modport = tail.strip_prefix('.').map(|m| m.trim().to_owned());
    (!def.is_empty()).then_some(VifShape {
        def,
        modport,
        params,
    })
}

/// What [`vif_shape`] reads from a virtual interface type's printed form.
struct VifShape {
    def: String,
    modport: Option<String>,
    /// The `#(NAME=VALUE, ...)` assignments, as printed.
    params: Vec<(String, String)>,
}

/// Whether slang lists a method call's receiver among its operands
/// (one more operand than the method has formals).
fn receiver_listed(e: &sv_lang::Expression<'_>) -> bool {
    e.call_subroutine()
        .is_some_and(|s| e.operands().len() == s.subroutine_arguments().count() + 1)
}

/// The `vpiNetType` constant of net kind `kind` (`vpiWire` for anything
/// without one of its own, such as a user-defined nettype).
fn net_type_const(kind: vj_sim::state::NetKind) -> i32 {
    use vj_sim::state::NetKind as K;
    let name = match kind {
        K::WAnd => "vpiWand",
        K::WOr => "vpiWor",
        K::Tri => "vpiTri",
        K::Tri0 => "vpiTri0",
        K::Tri1 => "vpiTri1",
        K::TriReg => "vpiTriReg",
        K::TriAnd => "vpiTriAnd",
        K::TriOr => "vpiTriOr",
        K::Supply0 => "vpiSupply0",
        K::Supply1 => "vpiSupply1",
        K::UWire => "vpiUwire",
        K::Wire | K::UserDefined => "vpiWire",
    };
    consts::value_of(name).expect("a vpi_user.h net type") as i32
}

/// Where a parameter name is written (37.58): see `Builder::classify_use`.
enum UseCtx<'t> {
    Modelled,
    Range(sv_lang::Node<'t>),
    Gen(Vec<sv_lang::Node<'t>>),
    Refused,
}

/// Where a parameter name sits in a generate construct (37.58).
enum GenPos<'t> {
    /// In the condition, bound or item expression; the expression nodes
    /// from the identifier upward.
    Cond(Vec<sv_lang::Node<'t>>),
    /// In the generated body (ordinary code).
    Body,
    Unknown,
}

struct Builder<'d> {
    model: VpiModel,
    /// The concurrent assertion whose structure is being built (its leaf
    /// operands' source ranges are recorded on it, `Props::expr_srcs`).
    cur_assertion: Option<ObjId>,
    /// The property/sequence declaration whose body is being built (the
    /// parent of its match-item statements, 37.54).
    decl_parent: Option<ObjId>,
    locator: Locator,
    /// `vpiFile`/`vpiDefFile`: the source file the design was read from.
    file: String,
    /// The instance body whose members are being added (the key of
    /// `run_design`'s per-instance signal maps).
    body: Option<SymbolId>,
    /// The definition name of that instance (an assertion's `vpiDefName`).
    def_name: Option<String>,
    /// Links resolved once every object exists: `(object, side, instance
    /// body, symbol)`, side 0 = `conn`, 1 = `rhs`, 2 = one of `reads`.
    links: Vec<(ObjId, u8, SymbolId, SymbolId)>,
    /// Expression operands naming a signal, resolved the same way:
    /// `(expression, operand position or -1 for a select base, body, symbol)`.
    expr_links: Vec<(ExprId, i32, Option<SymbolId>, SymbolId)>,
    /// The ref obj of each `ref` formal of a task or function by the formal's
    /// symbol: what a use of the formal in the body is (37.15 detail 1).
    tf_ref_by_uid: std::collections::HashMap<SymbolId, ObjId>,
    /// Constant-index selects and the parameters their folded bounds name
    /// (37.58 `vpiUse`), resolved in the post-pass: `(select, parameter)`.
    param_links: Vec<(ExprId, SymbolId)>,
    /// Identifier names written as a qualified name's part anywhere (lazy).
    qualified_idents: Option<std::collections::HashSet<String>>,
    /// Placeholders standing for a plainly named signal operand.
    pending_plain: Vec<ExprId>,
    /// The placeholders of `pending_plain` that name an automatic local (a
    /// subroutine formal or automatic variable): no object stands for them.
    pending_local: std::collections::HashSet<ExprId>,
    /// Declaration range expressions already bound for `vpiUse` (scope,
    /// tree, byte start, byte end).
    range_exprs: std::collections::HashSet<(SymbolId, usize, usize, usize)>,
    /// Names of parameters a qualified name uses where no expression could
    /// be bound (37.58): their `vpiUse` is refused.
    qual_fail: std::collections::HashSet<String>,
    /// Every parameter object built, by name.
    param_objs: Vec<(String, ObjId)>,
    /// Inline `randomize() with { }` constraint blocks built so far (their
    /// unique full names).
    inline_constraints: u32,
    /// `let` declarations by (syntax tree, start offset of their syntax):
    /// how an expansion's body is traced back to its declaration.
    let_decls: std::collections::HashMap<(usize, usize), ObjId>,
    /// Non-zero while a let expansion's body is being built (see
    /// [`Self::let_root`]).
    let_depth: u32,
    /// The unconsumed `let` invocations of the expression being built
    /// (see [`Self::let_root`]) and the depth of nested `operand` calls.
    let_sites: Vec<LetSite>,
    let_hint: Option<Vec<LetSite>>,
    /// The `let` invocations written in the statement being built: the
    /// fallback for an expression that is itself a bare expansion (`return
    /// f(a)`, `if (f(a))`), whose own syntax lies in the declaration.
    stmt_sites: Vec<LetSite>,
    op_depth: u32,
    /// Relations to objects found by their hierarchical path once every
    /// object exists: `(from, relation, path)`.
    path_links: Vec<(ObjId, i32, String)>,
    /// `(modport, tf io decl, interface tf decl path)`: resolved once every
    /// interface tf decl exists; only a real `InterfaceTfDecl` is linked.
    itf_tf_links: Vec<(ObjId, ObjId, String)>,
    /// Instance ports connected to a constant-indexed element of an array
    /// (`ica[i]` with a genvar `i`): `(port full name, element full name)`.
    select_conns: Vec<(String, String)>,
    /// Def params and the full names their target may have (37.28): the
    /// first that names a parameter is it.
    defparam_links: Vec<(ObjId, Vec<String>)>,
    /// `disable` statements and the scope and label they name (37.77).
    disable_links: Vec<(ObjId, String, String)>,
    /// The task/function objects by their subroutine symbol, and the
    /// relations and call expressions waiting for one (`vpiTask`/`vpiFunction`
    /// of a call; class methods are built under their class defn).
    tf_by_uid: std::collections::HashMap<SymbolId, ObjId>,
    /// A class defn's property objects by their symbol: what a name in its
    /// methods or constraints refers to; also a parameter's object, which a
    /// name in an expression (an indexed part select's base, 37.58) refers to.
    prop_by_uid: std::collections::HashMap<SymbolId, ObjId>,
    /// A sequence/property/let declaration's formal objects by their
    /// `AssertionPort` symbol: what a name in the declaration's bound body
    /// refers to (37.51, 37.53, 37.57).
    formal_by_uid: std::collections::HashMap<SymbolId, ObjId>,
    /// The formals (by name) of the declaration whose bound body is being
    /// built: a formal with no default binds as an `Invalid` placeholder
    /// that only its source text identifies.
    formal_names: Vec<(String, ObjId)>,
    /// Whether an expression written as a formal's name in the declaration's
    /// bound body is that formal: slang substitutes a defaulted formal's
    /// default there, so the written name is all that identifies it (set
    /// once the defaults are bound; 37.51, 37.53).
    formals_by_text: bool,
    /// The loop variables of the `foreach` constraints being built, by name
    /// (slang keeps no symbol for them on the constraint, 37.38 detail 2).
    loop_vars: Vec<(String, ObjId)>,
    tf_rel_links: Vec<(ObjId, i32, SymbolId)>,
    tf_call_links: Vec<(ExprId, SymbolId)>,
    /// The clocking event in effect where a property expression is being
    /// built (37.56: a multiclock sequence's operands are all clocked).
    ctx_clock: Option<Operand>,
    /// Member selects, resolved to their member objects in the post-pass.
    pending_members: Vec<ExprId>,
    /// The member's class and width of each pending member select, for one
    /// that turns out to be prefixed by a virtual interface or class variable.
    member_types: std::collections::HashMap<ExprId, (ObjKind, i32)>,
    /// The class and width of each intermediate member of a deeper path
    /// `a.b.c` (here `b`), in path order, per member expression.
    member_chain: std::collections::HashMap<ExprId, Vec<(ObjKind, i32)>>,
    /// The assertion objects by their statement's source offset, so the
    /// statement model links an assertion statement to its object.
    assertion_ids: std::collections::HashMap<u64, ObjId>,
    /// The interned typespec objects (`Builder::typespec`).
    typespecs: std::collections::HashMap<String, ObjId>,
    /// Every instance object by its instance symbol, for ref objs'
    /// `vpiActual`.
    instances: std::collections::HashMap<String, ObjId>,
    /// Ref objs whose actual is resolved once every object exists:
    /// `(ref obj, instance symbol key, modport name)`.
    ref_links: Vec<(ObjId, String, Option<String>)>,
    /// The evaluation session over the design: binds syntax slang never
    /// bound itself (`bind_expression`: a formal's default, IEEE 1800-2023
    /// 37.51/37.57).
    eval: &'d sv_lang::EvalSession<'d>,
}

/// The value of the header constant `name` (one the headers define).
fn header(name: &str) -> i32 {
    consts::value_of(name).expect("a header constant") as i32
}

/// The object tree of `design`, with `file` as the name of its source file.
pub fn build_model(design: &mut Design, file: &str) -> Result<VpiModel, VpiError> {
    let eval = design.eval_session();
    let design = eval.design();
    let mut b = Builder {
        model: VpiModel::new(),
        cur_assertion: None,
        decl_parent: None,
        locator: Locator::new(design),
        file: file.to_owned(),
        body: None,
        def_name: None,
        links: Vec::new(),
        expr_links: Vec::new(),
        tf_ref_by_uid: std::collections::HashMap::new(),
        param_links: Vec::new(),
        qualified_idents: None,
        pending_plain: Vec::new(),
        pending_local: std::collections::HashSet::new(),
        range_exprs: std::collections::HashSet::new(),
        qual_fail: std::collections::HashSet::new(),
        param_objs: Vec::new(),
        inline_constraints: 0,
        let_decls: std::collections::HashMap::new(),
        let_depth: 0,
        let_sites: Vec::new(),
        let_hint: None,
        stmt_sites: Vec::new(),
        op_depth: 0,
        path_links: Vec::new(),
        itf_tf_links: Vec::new(),
        select_conns: Vec::new(),
        defparam_links: Vec::new(),
        disable_links: Vec::new(),
        tf_by_uid: std::collections::HashMap::new(),
        prop_by_uid: std::collections::HashMap::new(),
        formal_by_uid: std::collections::HashMap::new(),
        formal_names: Vec::new(),
        formals_by_text: false,
        loop_vars: Vec::new(),
        tf_rel_links: Vec::new(),
        tf_call_links: Vec::new(),
        ctx_clock: None,
        pending_members: Vec::new(),
        member_types: std::collections::HashMap::new(),
        member_chain: std::collections::HashMap::new(),
        assertion_ids: std::collections::HashMap::new(),
        typespecs: std::collections::HashMap::new(),
        instances: std::collections::HashMap::new(),
        ref_links: Vec::new(),
        eval: &eval,
    };
    for top in design.top_instances() {
        let name = top.name().to_owned();
        b.instance(&top, None, &name, &name, None, true)?;
    }
    for package in design.packages() {
        // The built-in `std` package (`process`, `semaphore`, `mailbox`...)
        // is always present; hiding it keeps `vpiPackage` iteration to the
        // user's own packages (a documented deviation: the LRM lists every
        // package).
        if package.name() != "std" {
            b.package(&package);
        }
    }
    b.dpi_exports(design);
    // Expression operands and select bases (a select of a signal that is
    // not in the model stays unrepresented).
    for (e, pos, body, sym) in std::mem::take(&mut b.expr_links) {
        // A select of a class property (in its class's code) has the
        // property's object as its base.
        let target = body
            .as_ref()
            .and_then(|body| b.model.find_signal(body, &sym))
            .or_else(|| b.prop_by_uid.get(&sym).copied())
            .or_else(|| b.tf_ref_by_uid.get(&sym).copied());
        let Some(node) = b.model.expr_mut(e) else {
            continue;
        };
        match (node, target) {
            (ExprNode::Op { operands, .. }, Some(t)) if pos >= 0 => {
                operands[pos as usize] = Operand::Obj(t);
            }
            (
                ExprNode::BitSelect { base, .. }
                | ExprNode::PartSelect { base, .. }
                | ExprNode::IndexSelect { base, .. }
                | ExprNode::IndexedPartSelect { base, .. }
                | ExprNode::Member { base, .. },
                Some(t),
            ) => *base = t,
            (node, None) => *node = ExprNode::Unsupported("a reference outside the model".into()),
            _ => {}
        }
    }
    for (sel, sym) in std::mem::take(&mut b.param_links) {
        if let Some(p) = b.prop_by_uid.get(&sym).copied() {
            b.model.add_param_use(p, sel);
        }
    }
    // A plain name's placeholder becomes the object itself wherever it is
    // an operand (see `Builder::operand`).
    let pending = std::mem::take(&mut b.pending_plain);
    let mut plain: std::collections::HashMap<ExprId, Operand> = pending
        .iter()
        .filter_map(|&h| match b.model.expr(h) {
            Some(ExprNode::Op { operands, .. }) => match operands.first() {
                Some(Operand::Obj(o)) => Some((h, Operand::Obj(*o))),
                _ => None,
            },
            _ => None,
        })
        .collect();
    // A name the model has no object for (a local of a subroutine or
    // block, a member of an unmodelled scope) is a typed error, not an
    // operation with no operator.
    for &h in &pending {
        if !plain.contains_key(&h)
            && let Some(n) = b.model.expr_mut(h)
        {
            *n = ExprNode::Unsupported(if b.pending_local.contains(&h) {
                super::model::AUTOMATIC_LOCAL_REF.into()
            } else {
                "a reference to a name the VPI model has no object for (a member of \
                 an unmodelled scope)"
                    .into()
            });
        }
    }
    for h in std::mem::take(&mut b.pending_members) {
        let target = match b.model.expr(h) {
            Some(ExprNode::Member { base, path }) if *base != u32::MAX => b
                .model
                .get(*base)
                .and_then(|o| b.model.find(&format!("{}.{path}", o.full_name))),
            _ => None,
        };
        match target {
            Some(t) => {
                plain.insert(h, Operand::Obj(t));
            }
            None => {
                // A member of a virtual interface or class variable belongs
                // to whatever the variable designates at the time (37.61
                // detail 1): keep it with its prefix.
                let mut prefixed = None;
                if let (Some(ExprNode::Member { base, path }), Some(&(kind, size))) =
                    (b.model.expr(h).cloned(), b.member_types.get(&h))
                    && base != u32::MAX
                {
                    let bkind = b.model.get(base).map(|o| o.kind);
                    if bkind == Some(ObjKind::RefObj)
                        && b.model
                            .get(base)
                            .and_then(|o| b.model.get(o.parent?))
                            .is_some_and(|p| p.kind == ObjKind::TaskFunc)
                    {
                        // 37.15 details 1 and 4: `r.f` of a task or function
                        // `ref` formal is a ref obj under the formal's; its
                        // actual is the member of the call's actual.
                        prefixed = Some(ExprNode::PrefixedMember {
                            prefix: Operand::Obj(base),
                            name: path,
                            kind,
                            size,
                        });
                    } else if (!path.contains('.') && bkind == Some(ObjKind::ClassVar))
                        || bkind == Some(ObjKind::VirtualInterfaceVar)
                    {
                        // A virtual interface's path `sub.sig` is looked up
                        // in whatever interface the variable designates.
                        prefixed = Some(ExprNode::PrefixedMember {
                            prefix: Operand::Obj(base),
                            name: path,
                            kind,
                            size,
                        });
                    } else if bkind == Some(ObjKind::ClassVar) {
                        // A deeper path `a.b.c` (37.61 detail 1): each
                        // handle member on the way is itself a prefixed
                        // member, the prefix of the next.
                        let names: Vec<&str> = path.split('.').collect();
                        let mids = b.member_chain.get(&h).cloned().unwrap_or_default();
                        if mids.len() + 1 == names.len()
                            && mids.iter().all(|(k, _)| *k == ObjKind::ClassVar)
                        {
                            let mut prefix = Operand::Obj(base);
                            for (n, &(k, sz)) in names.iter().zip(&mids) {
                                prefix =
                                    Operand::Expr(b.model.add_expr(ExprNode::PrefixedMember {
                                        prefix,
                                        name: (*n).to_owned(),
                                        kind: k,
                                        size: sz,
                                    }));
                            }
                            prefixed = Some(ExprNode::PrefixedMember {
                                prefix,
                                name: names[names.len() - 1].to_owned(),
                                kind,
                                size,
                            });
                        }
                    }
                }
                if let Some(n) = b.model.expr_mut(h) {
                    *n = prefixed.unwrap_or_else(|| {
                        ExprNode::Unsupported("a member select outside the model".into())
                    });
                }
            }
        }
    }
    let fix = |o: &mut Operand| {
        if let Operand::Expr(e) = o
            && let Some(r) = plain.get(e)
        {
            *o = *r;
        }
    };
    for i in 0..b.model.expr_count() as ExprId {
        match b.model.expr_mut(i) {
            Some(ExprNode::Op { operands, .. })
            | Some(ExprNode::AssertInst { args: operands, .. }) => {
                operands.iter_mut().for_each(&fix);
            }
            Some(ExprNode::PrefixedElement { prefix, index, .. }) => {
                fix(prefix);
                fix(index);
            }
            Some(ExprNode::Call { args, prefix, .. }) => {
                args.iter_mut().for_each(&fix);
                if let Some(p) = prefix {
                    fix(p);
                }
            }
            Some(ExprNode::CaseProperty { cond, items }) => {
                fix(cond);
                items.iter_mut().for_each(&fix);
            }
            Some(ExprNode::CasePropItem { exprs, prop }) => {
                exprs.iter_mut().for_each(&fix);
                fix(prop);
            }
            Some(ExprNode::MulticlockSeq { seqs }) => seqs.iter_mut().for_each(&fix),
            Some(ExprNode::LetInst { args, body, .. }) => {
                args.iter_mut().for_each(&fix);
                fix(body);
            }
            Some(ExprNode::ValueRange { left, right }) => {
                fix(left);
                fix(right);
            }
            Some(ExprNode::ConstrOrdering { before, after }) => {
                before.iter_mut().chain(after.iter_mut()).for_each(&fix);
            }
            Some(ExprNode::Implication { cond, body }) => {
                fix(cond);
                body.iter_mut().for_each(&fix);
            }
            Some(ExprNode::ConstrIf { cond, body, els }) => {
                fix(cond);
                body.iter_mut().for_each(&fix);
                if let Some(e) = els {
                    e.iter_mut().for_each(&fix);
                }
            }
            Some(ExprNode::ConstrForeach { array, vars, body }) => {
                fix(array);
                vars.iter_mut().chain(body.iter_mut()).for_each(&fix);
            }
            Some(ExprNode::SoftDisable { expr }) => fix(expr),
            Some(ExprNode::Distribution { expr, items, .. }) => {
                fix(expr);
                items.iter_mut().for_each(&fix);
            }
            Some(ExprNode::DistItem { value, weight, .. }) => {
                fix(value);
                if let Some(w) = weight {
                    fix(w);
                }
            }
            Some(ExprNode::Clocked { clock, body, .. }) => {
                fix(clock);
                fix(body);
            }
            Some(ExprNode::IndexSelect { index: o, .. })
            | Some(ExprNode::IndexedPartSelect { start: o, .. }) => fix(o),
            Some(ExprNode::ExprSelect { base, sel, .. }) => {
                fix(base);
                match sel {
                    super::model::Sel::Bit(o) | super::model::Sel::Indexed(o, _) => fix(o),
                    super::model::Sel::Part(..) => {}
                }
            }
            _ => {}
        }
    }
    for i in 0..b.model.len() as ObjId {
        if let Some(p) = b.model.props_mut(i) {
            if let Some(o) = p.conn_op.as_mut() {
                fix(o);
            }
            if let Some(o) = p.rhs_op.as_mut() {
                fix(o);
            }
            p.rels.iter_mut().for_each(|(_, o)| fix(o));
            p.expr_srcs.iter_mut().for_each(|(_, o)| fix(o));
        }
    }
    for (id, rel, uid) in std::mem::take(&mut b.tf_rel_links) {
        if let Some(&t) = b.tf_by_uid.get(&uid)
            && let Some(p) = b.model.props_mut(id)
        {
            p.rels.push((rel, Operand::Obj(t)));
        }
    }
    for (e, uid) in std::mem::take(&mut b.tf_call_links) {
        if let Some(&t) = b.tf_by_uid.get(&uid)
            && let Some(ExprNode::Call { func, .. }) = b.model.expr_mut(e)
        {
            *func = Some(t);
        }
    }
    // A disable's block, task or function: the label looked up from the
    // enclosing scope outwards.
    for (id, scope, label) in std::mem::take(&mut b.disable_links) {
        let mut base = scope.as_str();
        let target = loop {
            let cand = if base.is_empty() {
                label.clone()
            } else {
                format!("{base}.{label}")
            };
            if let Some(t) = b.model.find(&cand) {
                break Some(t);
            }
            match base.rfind('.') {
                Some(i) => base = &base[..i],
                None if !base.is_empty() => base = "",
                None => break None,
            }
        };
        if let Some(t) = target {
            b.rel(id, consts::VPI_EXPR, Operand::Obj(t));
        }
    }
    // A def param's parameter, and its value as its right-hand side: slang
    // binds no expression for a defparam's value, so the value is a constant
    // (the parameter's at the end of elaboration, which the defparam set).
    for (id, candidates) in std::mem::take(&mut b.defparam_links) {
        let Some(t) = candidates.iter().find_map(|c| {
            b.model
                .find(c)
                .filter(|&t| b.model.get(t).is_some_and(|o| o.kind == ObjKind::Parameter))
        }) else {
            continue;
        };
        let rhs = b
            .model
            .get(t)
            .and_then(|o| o.props.param.clone())
            .map(|v| match v {
                ParamValue::Logic(l, signed) => ExprNode::Const {
                    value: l,
                    signed,
                    const_type: header("vpiDecConst"),
                },
                ParamValue::Real(r) => ExprNode::Const {
                    value: Logic::from_u64(r.to_bits(), 64),
                    signed: false,
                    const_type: consts::VPI_REAL_CONST,
                },
                ParamValue::Str(text) => ExprNode::Const {
                    value: Logic::from_string_val(text.as_bytes(), 8 * text.len().max(1) as u32),
                    signed: false,
                    const_type: header("vpiStringConst"),
                },
            });
        let rhs = rhs.map(|n| b.model.add_expr(n));
        if let Some(p) = b.model.props_mut(id) {
            p.rels.push((consts::VPI_LHS, Operand::Obj(t)));
            if let Some(r) = rhs {
                p.rels.push((consts::VPI_RHS, Operand::Expr(r)));
            }
        }
    }
    for (id, rel, path) in std::mem::take(&mut b.path_links) {
        if let Some(t) = b.model.find(&path)
            && let Some(p) = b.model.props_mut(id)
        {
            p.rels.push((rel, Operand::Obj(t)));
        }
    }
    for (mp, io, path) in std::mem::take(&mut b.itf_tf_links) {
        let Some(t) = b.model.find(&path).filter(|t| {
            b.model
                .get(*t)
                .is_some_and(|o| o.kind == ObjKind::InterfaceTfDecl)
        }) else {
            continue;
        };
        for (obj, rel) in [(io, consts::VPI_EXPR), (mp, header("vpiInterfaceTfDecl"))] {
            if let Some(p) = b.model.props_mut(obj) {
                p.rels.push((rel, Operand::Obj(t)));
            }
        }
    }
    b.interconnect_typespecs();
    // A ref obj's actual interface instance or modport.
    for (id, inst, modport) in std::mem::take(&mut b.ref_links) {
        let Some(&target) = b.instances.get(&inst) else {
            continue;
        };
        let actual = match modport {
            Some(m) => b.model.children(target).iter().copied().find(|&c| {
                b.model
                    .get(c)
                    .is_some_and(|o| o.kind == ObjKind::Modport && o.name == m)
            }),
            None => Some(target),
        };
        if let (Some(a), Some(p)) = (actual, b.model.props_mut(id)) {
            p.rels.push((header("vpiActual"), Operand::Obj(a)));
        }
    }
    let mut widths = Vec::new();
    for (id, side, body, sym) in std::mem::take(&mut b.links) {
        if side == 0
            && let Some(t) = b.model.find_signal(&body, &sym)
            && b.model
                .get(id)
                .is_some_and(|o| o.kind == ObjKind::ContAssign)
        {
            widths.push((id, b.model.get(t).map_or(0, |o| o.props.width)));
        }
        b.links.push((id, side, body, sym));
    }
    for (id, side, body, sym) in std::mem::take(&mut b.links) {
        let Some(target) = b.model.find_signal(&body, &sym) else {
            continue;
        };
        if let Some(p) = b.model.props_mut(id) {
            match side {
                0 => p.conn = Some(target),
                1 => p.rhs = Some(target),
                _ => {
                    if !p.reads.contains(&target) {
                        p.reads.push(target);
                    }
                }
            }
        }
    }
    for (id, w) in widths {
        if let Some(p) = b.model.props_mut(id)
            && p.width == 0
        {
            p.width = w;
        }
    }
    // A net declaration's assignment knows its net.
    let decl: Vec<(ObjId, i32)> = b
        .model
        .objects()
        .filter(|(_, o)| o.kind == ObjKind::ContAssign && o.props.width == 0)
        .filter_map(|(i, o)| {
            o.props
                .conn
                .and_then(|c| b.model.get(c))
                .map(|t| (i, t.props.width))
        })
        .collect();
    for (id, w) in decl {
        if let Some(p) = b.model.props_mut(id) {
            p.width = w;
        }
    }
    Ok(b.model)
}

/// `vpiDefNetType` for a `` `default_nettype ``.
fn def_net_type(kind: NetKind) -> Result<i32, VpiError> {
    Ok(match kind {
        NetKind::Wire => consts::VPI_WIRE,
        NetKind::WAnd => consts::VPI_WAND,
        NetKind::WOr => consts::VPI_WOR,
        NetKind::Tri => consts::VPI_TRI,
        NetKind::TriAnd => consts::VPI_TRI_AND,
        NetKind::TriOr => consts::VPI_TRI_OR,
        NetKind::Tri0 => consts::VPI_TRI0,
        NetKind::Tri1 => consts::VPI_TRI1,
        NetKind::TriReg => consts::VPI_TRI_REG,
        NetKind::Supply0 => consts::VPI_SUPPLY0,
        NetKind::Supply1 => consts::VPI_SUPPLY1,
        NetKind::UWire => consts::VPI_UWIRE,
        NetKind::Interconnect => consts::VPI_INTERCONNECT,
        // `` `default_nettype none ``: no implicit nets.
        NetKind::Unknown => consts::VPI_NONE,
        other => {
            return Err(VpiError::unsupported(
                &format!("a default net type of {other:?}"),
                "a vpiDefNetType value for it",
            ));
        }
    })
}

/// The declared index of element `i` (0-based position) of an array declared
/// with `range`: elements run from the left bound to the right one.
fn element_index(range: ConstantRange, i: usize) -> i32 {
    if range.left >= range.right {
        range.left - i as i32
    } else {
        range.left + i as i32
    }
}

impl Builder<'_> {
    fn add(&mut self, obj: Obj) -> ObjId {
        self.model.add(obj)
    }

    /// `vpiLibrary` of an instance of `def` (LRM 1800-2023 33.7): the library
    /// it was compiled into (`work` unless a library map says otherwise,
    /// 33.3.1). `vpiConfig` is not recorded: slang does not expose which
    /// config controls an elaborated instance (see `Props::library`).
    fn library_of(def: &Symbol<'_>) -> String {
        def.source_library()
            .map_or_else(|| "work".to_owned(), |l| l.name())
    }

    /// The `ObjKind` a definition declares.
    fn instance_kind(def: &Symbol<'_>) -> ObjKind {
        match def.definition_kind() {
            Some(DefinitionKind::Interface) => ObjKind::Interface,
            Some(DefinitionKind::Program) => ObjKind::Program,
            Some(DefinitionKind::Module) | None => ObjKind::Module,
        }
    }

    /// One instance and everything inside it. `name` is its `vpiName` (for an
    /// array element it carries the index, `u[2]`), `index` its declared index
    /// if it is an element of an array.
    fn instance(
        &mut self,
        inst: &Symbol<'_>,
        parent: Option<ObjId>,
        name: &str,
        full_name: &str,
        index: Option<i32>,
        top: bool,
    ) -> Result<ObjId, VpiError> {
        let (Some(body), Some(def)) = (inst.instance_body(), inst.instance_definition()) else {
            return Err(VpiError::bad_argument(format!(
                "instance {full_name} has no body or definition in the elaborated design"
            )));
        };
        let (time_unit, time_precision) = vj_codegen::timescale::unit_and_precision(&body);
        let def_net_type = match body.default_net_type() {
            Some(t) => def_net_type(t.net_kind())?,
            None => consts::VPI_WIRE,
        };
        let line = self.locator.line(inst);
        let def_line = self.locator.line(&def);
        let mut obj = Obj::new(Self::instance_kind(&def), parent, name, full_name);
        obj.props = Props {
            def_name: Some(def.name().to_owned()),
            library: Some(Self::library_of(&def)),
            cell_name: Some(def.name().to_owned()),
            top,
            cell: def.definition_cell_define(),
            automatic: def.definition_default_lifetime() == Some(VariableLifetime::Automatic),
            index,
            size: None,
            time_unit,
            time_precision,
            def_net_type,
            unconn_drive: match def.definition_unconnected_drive() {
                Some(UnconnectedDrive::Pull0) => consts::VPI_PULL0,
                Some(UnconnectedDrive::Pull1) => consts::VPI_PULL1,
                Some(UnconnectedDrive::None) | None => consts::VPI_HIGH_Z,
            },
            def_delay_mode: consts::VPI_DELAY_MODE_NONE,
            file: Some(self.file.clone()),
            // A top-level instance is made by the tool: it sits where its
            // definition does.
            line: if line == 0 { def_line } else { line },
            def_file: Some(self.file.clone()),
            def_line,
            // Module-wide statement callbacks (38.36.1.1) match on the body.
            dyn_key: Some((body.uid(), body.uid())),
            ..Props::default()
        };
        let id = self.add(obj);
        self.instances.insert(format!("{:?}", inst.uid()), id);
        self.attributes(inst.attributes(), id, full_name, false);
        self.attributes(def.attributes(), id, full_name, true);
        // The port connections are expressions of the instantiating scope:
        // bound while it is still the current one.
        let mut high: std::collections::HashMap<String, Operand> = std::collections::HashMap::new();
        for c in inst.instance_port_connections() {
            // An output's connection is bound as an assignment to it.
            let e = c.expression().map(|e| {
                if e.kind() == sv_lang::kinds::ExpressionKind::Assignment {
                    e.left().unwrap_or(e)
                } else {
                    e
                }
            });
            if let Some(e) = e
                && let Some(op) = self.operand(&e)
            {
                high.insert(c.port().name().to_owned(), op);
                if let Some(path) = Self::const_select_path(&e) {
                    self.select_conns
                        .push((format!("{full_name}.{}", c.port().name()), path));
                }
            }
        }
        let ports_by_name = self.instantiation_syntax(inst);
        let conn_texts = self.connection_texts(inst);
        let outer = self.body.replace(body.uid());
        let outer_def = self.def_name.replace(def.name().to_owned());
        self.members(&body, id, full_name)?;
        self.ports(&body, id, full_name, &high, ports_by_name, &conn_texts);
        self.param_assigns(inst, id, full_name);
        self.qualified_uses(&body);
        self.body = outer;
        self.def_name = outer_def;
        Ok(id)
    }

    /// The ports of an instance, in declaration order, each connected
    /// (`vpiLowConn`) to the net or variable of the same name inside.
    fn ports(
        &mut self,
        body: &Symbol<'_>,
        parent: ObjId,
        parent_name: &str,
        high: &std::collections::HashMap<String, Operand>,
        by_name: bool,
        conn_texts: &[(Option<String>, String)],
    ) {
        for (i, port) in body.instance_body_ports().enumerate() {
            if port.kind() == SymbolKind::InterfacePort {
                // The connection names a modport iff it selects one (`i.mp`);
                // a plain interface instance connects the instance.
                let ordered = conn_texts.iter().filter(|(n, _)| n.is_none()).nth(i);
                let text = conn_texts
                    .iter()
                    .find(|(n, _)| n.as_deref() == Some(port.name()))
                    .or(ordered)
                    .map(|(_, t)| t.clone());
                let high_modport = text.is_some_and(|t| t.contains('.'));
                self.interface_port(&port, i, parent, parent_name, by_name, high_modport);
                continue;
            }
            if port.kind() != SymbolKind::Port {
                continue;
            }
            let name = port.name().to_owned();
            let full = format!("{parent_name}.{name}");
            let mut obj = Obj::new(ObjKind::Port, Some(parent), &name, &full);
            obj.props.port_type = header("vpiPort");
            obj.props.explicit_name = self.port_is_explicit(&port);
            obj.props.conn_by_name = by_name;
            if let Some(h) = high.get(&name) {
                obj.props.rels.push((consts::VPI_HIGH_CONN, *h));
            }
            obj.props.direction = match port.port_direction() {
                ArgumentDirection::In => consts::VPI_INPUT,
                ArgumentDirection::Out => consts::VPI_OUTPUT,
                ArgumentDirection::InOut => consts::VPI_INOUT,
                ArgumentDirection::Ref => consts::VPI_REF,
            };
            obj.props.index = Some(i as i32);
            obj.props.file = Some(self.file.clone());
            obj.props.line = self.locator.line(&port);
            let internal = port.port_internal_symbol();
            if let Some(ty) = internal.and_then(|s| s.value_type()) {
                obj.props.width = ty.bit_width() as i32;
                obj.props.signed = ty.is_signed();
                obj.props.vector = ty.is_packed_array() || ty.bit_width() > 1;
                let c = ty.canonical();
                if c.is_packed_array() {
                    let r = c.fixed_range();
                    obj.props.range = Some((r.left, r.right));
                } else if c.is_integral() && c.bit_width() > 1 {
                    obj.props.range = Some((c.bit_width() as i32 - 1, 0));
                }
            }
            // The port's own net/variable: the internal symbol it names
            // (an explicitly named port, `.e(i1)`, names another).
            let internal_name = internal.map_or(name.clone(), |s| s.name().to_owned());
            let target = self.model.children(parent).iter().copied().find(|&c| {
                self.model
                    .get(c)
                    .is_some_and(|o| o.kind.is_data() && o.name == internal_name)
            });
            let id = self.add(obj);
            self.attributes(port.attributes(), id, &full, false);
            self.typespec_rel(id, port.port_type());
            // A `ref` port's low conn is a ref obj whose actual is what the
            // instance connects (37.15 detail 1).
            if port.port_direction() == ArgumentDirection::Ref {
                let mut r = Obj::new(ObjKind::RefObj, Some(id), &name, &full);
                r.props.file = Some(self.file.clone());
                r.props.line = self.locator.line(&port);
                // The connected variable, or sub-element of one (a plain
                // name is a placeholder node patched to the object itself).
                if let Some(a) = high.get(&name) {
                    r.props.rels.push((header("vpiActual"), *a));
                }
                let rid = self.add(r);
                self.typespec_rel(rid, port.port_type());
                self.model.set_low_conn(id, rid);
            } else if let Some(target) = target {
                self.model.set_low_conn(id, target);
            }
        }
    }

    /// An interface or modport port (37.14): its low conn and high conn
    /// are ref objs (37.15) whose actual is the connected interface
    /// instance or modport.
    fn interface_port(
        &mut self,
        port: &Symbol<'_>,
        i: usize,
        parent: ObjId,
        parent_name: &str,
        by_name: bool,
        high_modport: bool,
    ) {
        let name = port.name().to_owned();
        let full = format!("{parent_name}.{name}");
        let modport = port.interface_port_modport().to_owned();
        let mut obj = Obj::new(ObjKind::Port, Some(parent), &name, &full);
        obj.props.port_type = header(if modport.is_empty() {
            "vpiInterfacePort"
        } else {
            "vpiModportPort"
        });
        obj.props.direction = consts::VPI_INOUT;
        obj.props.index = Some(i as i32);
        obj.props.explicit_name = self.port_is_explicit(port);
        obj.props.conn_by_name = by_name;
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(port);
        let id = self.add(obj);
        self.attributes(port.attributes(), id, &full, false);
        let (inst, mp) = port.interface_port_connection();
        let def = port
            .interface_port_interface_def()
            .map(|d| d.name().to_owned())
            .unwrap_or_default();
        let link = inst.map(|s| format!("{:?}", s.uid()));
        let mp_name = mp.map(|m| m.name().to_owned());
        let def_name = mp_name.clone().unwrap_or(def);
        // The low conn: the port's own declaration in this instance.
        let mut low = Obj::new(ObjKind::RefObj, Some(id), &name, &full);
        low.props.def_name = Some(def_name.clone());
        low.props.generic = Some(port.interface_port_is_generic());
        low.props.file = Some(self.file.clone());
        low.props.line = self.locator.line(port);
        let lid = self.add(low);
        self.model.set_low_conn(id, lid);
        // The high conn: the connection in the instantiating scope.
        let high_mp = mp_name.clone().filter(|_| high_modport);
        let hname = match (&inst, &high_mp) {
            (Some(s), Some(m)) => format!("{}.{m}", s.name()),
            (Some(s), None) => s.name().to_owned(),
            _ => String::new(),
        };
        let mut hi = Obj::new(ObjKind::RefObj, Some(id), &hname, &hname);
        hi.props.def_name = Some(high_mp.clone().unwrap_or_else(|| {
            inst.and_then(|s| s.instance_definition())
                .map(|d| d.name().to_owned())
                .unwrap_or(def_name)
        }));
        hi.props.generic = Some(port.interface_port_is_generic());
        hi.props.file = Some(self.file.clone());
        let hid = self.add(hi);
        if let Some(p) = self.model.props_mut(id) {
            p.rels.push((consts::VPI_HIGH_CONN, Operand::Obj(hid)));
        }
        if let Some(link) = link {
            self.ref_links.push((lid, link.clone(), mp_name));
            self.ref_links.push((hid, link, high_mp));
        }
    }

    /// The port connections of an instance as written: `(Some(port), text)`
    /// for a named one, `(None, text)` for an ordered one.
    fn connection_texts(&self, inst: &Symbol<'_>) -> Vec<(Option<String>, String)> {
        use sv_lang::kinds::SyntaxKind;
        for t in self.locator.syntax_trees() {
            let Some(node) = inst.syntax(&t) else {
                continue;
            };
            let mut out = Vec::new();
            for d in node.descendants() {
                match d.kind() {
                    SyntaxKind::NamedPortConnection => {
                        if let Some(n) =
                            <sv_lang::nodes::NamedPortConnectionSyntax as sv_lang::AstNode>::cast(d)
                        {
                            let name = n.name().map(|t| t.value_text().to_owned());
                            let text = n
                                .expr()
                                .map(|e| sv_lang::AstNode::syntax(&e).text())
                                .unwrap_or_default();
                            out.push((name, text.trim().to_owned()));
                        }
                    }
                    SyntaxKind::OrderedPortConnection => {
                        out.push((None, d.text().trim().to_owned()));
                    }
                    _ => {}
                }
            }
            return out;
        }
        Vec::new()
    }

    /// Whether `port` is declared with an explicit name (`.name(expr)`,
    /// 37.14 detail 8).
    fn port_is_explicit(&self, port: &Symbol<'_>) -> bool {
        use sv_lang::kinds::SyntaxKind;
        // The port's own syntax is its declarator or port reference; the
        // explicit form (`.name(expr)`) encloses it.
        self.locator.syntax_trees().iter().any(|t| {
            let mut node = port.syntax(t);
            while let Some(n) = node {
                match n.kind() {
                    SyntaxKind::ExplicitAnsiPort | SyntaxKind::ExplicitNonAnsiPort => return true,
                    SyntaxKind::ImplicitAnsiPort
                    | SyntaxKind::ImplicitNonAnsiPort
                    | SyntaxKind::AnsiPortList
                    | SyntaxKind::NonAnsiPortList => return false,
                    _ => node = n.parent(),
                }
            }
            false
        })
    }

    /// From an instance's syntax: whether its ports are connected by name.
    fn instantiation_syntax(&self, inst: &Symbol<'_>) -> bool {
        use sv_lang::kinds::SyntaxKind;
        for t in self.locator.syntax_trees() {
            let Some(node) = inst.syntax(&t) else {
                continue;
            };
            let kinds: Vec<SyntaxKind> = node.descendants().map(|d| d.kind()).collect();
            let ordered = kinds.contains(&SyntaxKind::OrderedPortConnection);
            return !ordered
                && (kinds.contains(&SyntaxKind::NamedPortConnection)
                    || kinds.contains(&SyntaxKind::WildcardPortConnection));
        }
        false
    }

    /// The parameter overrides of an instance (37.28 `vpiParamAssign`):
    /// `vpiLhs` the overridden parameter of the instance body, `vpiRhs` its
    /// value. `instance_parameter_overrides` lists the `#(...)` and config
    /// overrides (defparams are `DefParam` symbols instead); `vpiConnByName`
    /// is "supplied by name".
    fn param_assigns(&mut self, inst: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        for o in inst.instance_parameter_overrides() {
            let param = o.parameter;
            let by_name = o.assignment == sv_lang::ParameterAssignment::Named;
            let pname = param.name().to_owned();
            let Some(lhs) = self.model.find(&format!("{parent_name}.{pname}")) else {
                continue;
            };
            let mut a = Obj::new(ObjKind::ParamAssign, Some(parent), "", "");
            a.props.conn_by_name = by_name;
            a.props.file = Some(self.file.clone());
            a.props.line = self.locator.line(&param);
            a.props.rels.push((consts::VPI_LHS, Operand::Obj(lhs)));
            let rhs = if param.kind() == SymbolKind::TypeParameter {
                param
                    .declared_type()
                    .and_then(|t| self.typespec(&t))
                    .map(Operand::Obj)
            } else if let Some(op) = self.override_expression(&o) {
                Some(op)
            } else {
                self.model
                    .get(lhs)
                    .and_then(|o| match &o.props.param {
                        Some(ParamValue::Logic(l, signed)) => Some(ExprNode::Const {
                            value: l.clone(),
                            signed: *signed,
                            const_type: consts::VPI_BINARY_CONST,
                        }),
                        _ => None,
                    })
                    .map(|n| Operand::Expr(self.model.add_expr(n)))
            };
            if let Some(r) = rhs {
                a.props.rels.push((consts::VPI_RHS, r));
            }
            // 37.58: a parameter named in an override value that has no
            // expression object here stays refused by name.
            if let Some(e) = o.value_expr() {
                let e = unwrap_invalid_expr(e);
                let mut named = Vec::new();
                Self::named_parameters(&e, &mut named);
                let modelled = a.props.rels.iter().any(|(k, r)| {
                    *k == consts::VPI_RHS
                        && match r {
                            Operand::Expr(x) => {
                                matches!(self.model.expr(*x), Some(ExprNode::Op { .. }))
                            }
                            Operand::Obj(p) => self
                                .model
                                .get(*p)
                                .is_some_and(|o| o.kind == ObjKind::Parameter),
                        }
                });
                if !modelled {
                    for p in named {
                        if let Some(id) = self.prop_by_uid.get(&p).copied() {
                            self.model.mark_param_folded(id);
                        }
                    }
                }
            }
            self.add(a);
        }
    }

    /// The `vpiRhs` of an override whose value expression names parameters
    /// (`#(.W(S + 1))`, 37.58): the expression itself, bound in the
    /// instantiating scope, so the named parameters have a `vpiUse` there.
    /// A bare name (`#(.W(S))`) is the parameter object itself; a value
    /// without parameters stays the folded constant.
    fn override_expression(&mut self, o: &sv_lang::ParameterOverride<'_>) -> Option<Operand> {
        let e = unwrap_invalid_expr(o.value_expr()?);
        if e.is_bad() {
            return None;
        }
        let mut named = Vec::new();
        Self::named_parameters(&e, &mut named);
        if named.is_empty() {
            return None;
        }
        // A bare name is the parameter object itself; the holder of the use
        // is the ParamAssign.
        self.operand(&e)
    }

    /// One `NAME=VALUE` parameter assignment of an interface typespec
    /// (37.30 detail 3): a `vpiParamAssign` child whose `vpiLhs` is a
    /// parameter named `name` and whose `vpiRhs` is the value. An integer
    /// value is a signed 32-bit constant; any other printed value is a loud
    /// [`ExprNode::Unsupported`].
    fn interface_param_assign(&mut self, ts: ObjId, name: &str, value: &str) {
        let mut p = Obj::new(ObjKind::Parameter, Some(ts), name, "");
        let rhs = match value.parse::<i64>() {
            Ok(v) => {
                let l = Logic::from_u64(v as u64, 32);
                p.props.param = Some(ParamValue::Logic(l.clone(), true));
                ExprNode::Const {
                    value: l,
                    signed: true,
                    const_type: consts::VPI_BINARY_CONST,
                }
            }
            Err(_) => ExprNode::Unsupported(format!(
                "the value `{value}` of interface parameter {name} (only integers are decoded)"
            )),
        };
        let lhs = self.add(p);
        let mut a = Obj::new(ObjKind::ParamAssign, Some(ts), "", "");
        a.props.rels.push((consts::VPI_LHS, Operand::Obj(lhs)));
        let e = self.model.add_expr(rhs);
        a.props.rels.push((consts::VPI_RHS, Operand::Expr(e)));
        self.add(a);
    }

    /// The VPI class of a net or variable of type `ty`.
    fn data_kind(ty: &Type<'_>, net: bool) -> ObjKind {
        let var = Self::var_kind(ty);
        if !net {
            return var;
        }
        match var {
            ObjKind::StructVar => ObjKind::StructNet,
            ObjKind::UnionVar => ObjKind::UnionNet,
            ObjKind::EnumVar => ObjKind::EnumNet,
            ObjKind::IntegerVar => ObjKind::IntegerNet,
            ObjKind::TimeVar => ObjKind::TimeNet,
            ObjKind::BitVar => ObjKind::BitNet,
            ObjKind::ByteVar => ObjKind::ByteNet,
            ObjKind::ShortIntVar => ObjKind::ShortIntNet,
            ObjKind::IntVar => ObjKind::IntNet,
            ObjKind::LongIntVar => ObjKind::LongIntNet,
            ObjKind::RealVar => ObjKind::RealNet,
            ObjKind::ShortRealVar => ObjKind::ShortRealNet,
            ObjKind::PackedArrayVar => ObjKind::PackedArrayNet,
            _ => ObjKind::Net,
        }
    }

    /// Whether `ty` is a packed array of packed structs, unions, enums or
    /// packed arrays (a multidimensional packed vector, 37.17 detail 3).
    fn packed_array_of_aggregates(ty: &Type<'_>) -> bool {
        let ty = ty.canonical();
        if !ty.is_packed_array() {
            return false;
        }
        let Some(elem) = ty.element_type().map(|e| e.canonical()) else {
            return false;
        };
        elem.is_struct()
            || elem.is_packed_union()
            || elem.is_enum()
            || Self::packed_array_of_aggregates(&elem)
    }

    /// Whether a variable of type `ty` is built as a packed array object
    /// with one child per element: [`Self::packed_array_of_aggregates`], or
    /// a multidimensional packed vector (`logic [3:0][7:0]`), whose elements
    /// are packed arrays of bits (37.17 detail 3). Its typespec stays the
    /// plain logic/bit one.
    fn packed_array_objects(ty: &Type<'_>) -> bool {
        let ty = ty.canonical();
        ty.is_packed_array()
            && ty
                .element_type()
                .is_some_and(|e| e.canonical().is_packed_array())
            || Self::packed_array_of_aggregates(&ty)
    }

    /// The VPI class of a variable of type `ty`.
    fn var_kind(ty: &Type<'_>) -> ObjKind {
        let ty = ty.canonical();
        if ty.is_event() {
            return ObjKind::NamedEvent;
        }
        if ty.is_virtual_interface() {
            return ObjKind::VirtualInterfaceVar;
        }
        // An unpacked array (fixed, dynamic, queue or associative) that is
        // not built element by element (a class property): an array var.
        if ty.is_unpacked_array() || vj_sim::state::storage::is_collection(&ty) {
            return ObjKind::RegArray;
        }
        if ty.is_class() {
            return ObjKind::ClassVar;
        }
        if Self::packed_array_objects(&ty) {
            return ObjKind::PackedArrayVar;
        }
        if ty.is_chandle() {
            return ObjKind::ChandleVar;
        }
        if ty.is_floating() {
            return match ty.floating_kind() {
                FloatKind::ShortReal => ObjKind::ShortRealVar,
                FloatKind::Real | FloatKind::RealTime => ObjKind::RealVar,
            };
        }
        if ty.is_string() {
            return ObjKind::StringVar;
        }
        if ty.is_enum() {
            return ObjKind::EnumVar;
        }
        if ty.is_packed_union() || ty.is_unpacked_union() {
            return ObjKind::UnionVar;
        }
        if ty.is_struct() {
            return ObjKind::StructVar;
        }
        if ty.is_predefined_integer() {
            return match ty.predefined_integer_kind() {
                PredefinedIntegerKind::ShortInt => ObjKind::ShortIntVar,
                PredefinedIntegerKind::Int => ObjKind::IntVar,
                PredefinedIntegerKind::LongInt => ObjKind::LongIntVar,
                PredefinedIntegerKind::Byte => ObjKind::ByteVar,
                PredefinedIntegerKind::Integer => ObjKind::IntegerVar,
                PredefinedIntegerKind::Time => ObjKind::TimeVar,
            };
        }
        if ty.is_four_state() {
            ObjKind::Reg
        } else {
            ObjKind::BitVar
        }
    }

    /// A net or variable `sym` (of `scope`), with its elements if it is an
    /// unpacked array; an interconnect or user-nettype net retyped (37.17
    /// details 11-13).
    fn data(&mut self, sym: &Symbol<'_>, parent: ObjId, parent_name: &str, net: bool) {
        let first = self.model.len() as ObjId;
        self.data_objects(sym, parent, parent_name, net);
        let last = self.model.len() as ObjId;
        if net && first != last {
            // 37.16: every net object of the declaration, array nets, their
            // elements and the parts of a packed or struct net included,
            // carries the declared net type (a user nettype or interconnect
            // is retyped below).
            let nt = net_type_const(crate::nets::net_kind_of(sym, &self.locator.syntax_trees()));
            for id in first..last {
                let unset = self
                    .model
                    .get(id)
                    .is_some_and(|o| o.kind.is_net() && o.props.net_type == 0);
                if unset && let Some(p) = self.model.props_mut(id) {
                    p.net_type = nt;
                }
            }
        }
        if sym.value_type().is_some_and(|t| {
            let mut e = t.canonical();
            while e.is_unpacked_array()
                && let Some(x) = e.element_type()
            {
                e = x.canonical();
            }
            e.is_virtual_interface()
        }) {
            self.vif_details(sym, first, last);
        }
        if !net || first == last {
            return;
        }
        let interconnect = sym
            .value_type()
            .is_some_and(|t| vj_sim::state::storage::interconnect_dims(&t).is_some());
        let user = !interconnect && self.user_nettype_of(sym).is_some();
        if !interconnect && !user {
            return;
        }
        // The net itself (or its array), then its elements: the first object
        // built and its direct net children.
        let elements: Vec<ObjId> = self.model.children(first).to_vec();
        for id in first..last {
            let Some(kind) = self.model.get(id).map(|o| o.kind) else {
                continue;
            };
            if !kind.is_net() {
                continue;
            }
            let whole = id == first
                || (elements.contains(&id)
                    && self
                        .model
                        .get(first)
                        .is_some_and(|o| o.kind.is_data_array()));
            if interconnect {
                // 37.17 detail 13 (and an interconnect is typeless).
                self.model.set_kind(
                    id,
                    if kind.is_data_array() {
                        ObjKind::InterconnectArray
                    } else {
                        ObjKind::InterconnectNet
                    },
                );
                if let Some(p) = self.model.props_mut(id) {
                    p.net_type = consts::VPI_INTERCONNECT;
                    p.rels.retain(|(r, _)| *r != header("vpiTypespec"));
                }
            } else if let Some(p) = self.model.props_mut(id) {
                // 37.17 detail 11.
                p.net_type = header(if whole {
                    "vpiNettypeNet"
                } else {
                    "vpiNettypeNetSelect"
                });
            }
        }
    }

    /// The hierarchical path of the element `e` selects by constant indices
    /// (`top.ica2[0][3]`), or `None` if `e` is not such a select.
    fn const_select_path(e: &sv_lang::Expression<'_>) -> Option<String> {
        use sv_lang::kinds::ExpressionKind as K;
        match e.kind() {
            K::NamedValue => Some(e.referenced_symbol()?.hierarchical_path()),
            K::ElementSelect => {
                let base = Self::const_select_path(&e.select_value()?)?;
                let i = e.selector()?.constant_value()?.as_i64()?;
                Some(format!("{base}[{i}]"))
            }
            _ => None,
        }
    }

    /// 37.24 detail 1: an interconnect net's typespec is the typespec of the
    /// net it is connected to, here the type of the instance port it is the
    /// connection (`vpiHighConn`) of. An interconnect array's typespec is the
    /// unpacked array of its elements' (a synthesized `vpiArrayTypespec` per
    /// dimension, each the next one's `vpiElemTypespec`).
    fn interconnect_typespecs(&mut self) {
        let typespec = header("vpiTypespec");
        let mut leaf: std::collections::HashMap<ObjId, ObjId> = std::collections::HashMap::new();
        for (_, o) in self.model.objects() {
            if o.kind != ObjKind::Port {
                continue;
            }
            let ts = o.props.rels.iter().find_map(|(r, t)| match t {
                Operand::Obj(t) if *r == typespec => Some(*t),
                _ => None,
            });
            let high = o.props.rels.iter().find_map(|(r, t)| {
                if *r != consts::VPI_HIGH_CONN {
                    return None;
                }
                match t {
                    Operand::Obj(t) => Some(*t),
                    Operand::Expr(_) => None,
                }
            });
            let high = high.or_else(|| {
                // `ica[i]`: the element a constant select names.
                let (_, el) = self.select_conns.iter().find(|(p, _)| *p == o.full_name)?;
                self.model.find(el)
            });
            if let (Some(ts), Some(h)) = (ts, high)
                && self
                    .model
                    .get(h)
                    .is_some_and(|n| n.kind == ObjKind::InterconnectNet)
            {
                leaf.entry(h).or_insert(ts);
            }
        }
        let mut leaves: Vec<(ObjId, ObjId)> = leaf.into_iter().collect();
        leaves.sort_unstable();
        for (net, ts) in leaves {
            self.rel(net, typespec, Operand::Obj(ts));
            self.interconnect_members(net, ts);
        }
        // Arrays, innermost first (a child is created after its array).
        let arrays: Vec<ObjId> = self
            .model
            .objects()
            .filter(|(_, o)| o.kind == ObjKind::InterconnectArray)
            .map(|(i, _)| i)
            .collect();
        for arr in arrays.into_iter().rev() {
            // The first element with a typespec gives the element type.
            let elem = self.model.children(arr).iter().find_map(|&c| {
                self.model.get(c).and_then(|o| {
                    o.props.rels.iter().find_map(|(r, t)| match t {
                        Operand::Obj(t) if *r == typespec => Some(*t),
                        _ => None,
                    })
                })
            });
            let Some(elem) = elem else { continue };
            let Some(range) = self.model.get(arr).and_then(|o| o.props.range) else {
                continue;
            };
            let mut ts = Obj::new(ObjKind::Typespec, None, "", "");
            ts.props.stmt_type = header("vpiArrayTypespec");
            ts.props.array_type = header("vpiStaticArray");
            ts.props.file = Some(self.file.clone());
            ts.props.dims = vec![range];
            ts.props.range = Some(range);
            let id = self.add(ts);
            self.rel(id, header("vpiElemTypespec"), Operand::Obj(elem));
            self.rel(arr, typespec, Operand::Obj(id));
        }
    }

    /// 37.24 detail 1: an interconnect net whose typespec is a packed or
    /// unpacked struct (or union) has the struct's members as its `vpiMember`
    /// interconnect nets, each typed by the member's typespec; a member that
    /// is itself a struct has members in turn.
    fn interconnect_members(&mut self, net: ObjId, ts: ObjId) {
        let struct_ts = [header("vpiStructTypespec"), header("vpiUnionTypespec")];
        let is_struct = self
            .model
            .get(ts)
            .is_some_and(|t| struct_ts.contains(&t.props.stmt_type));
        if !is_struct {
            return;
        }
        let Some(parent) = self.model.get(net).map(|n| n.full_name.clone()) else {
            return;
        };
        for m in self.model.children_of_kind(ts, ObjKind::TypespecMember) {
            let Some(mo) = self.model.get(m) else {
                continue;
            };
            let name = mo.name.clone();
            let mts = mo.props.rels.iter().find_map(|(r, t)| match t {
                Operand::Obj(t) if *r == header("vpiTypespec") => Some(*t),
                _ => None,
            });
            let line = mo.props.line;
            let mut obj = Obj::new(
                ObjKind::InterconnectNet,
                Some(net),
                &name,
                &format!("{parent}.{name}"),
            );
            obj.props.net_type = consts::VPI_INTERCONNECT;
            obj.props.file = Some(self.file.clone());
            obj.props.line = line;
            let id = self.add(obj);
            if let Some(mts) = mts {
                self.rel(id, header("vpiTypespec"), Operand::Obj(mts));
                self.interconnect_members(id, mts);
            }
        }
    }

    /// A virtual interface variable's (or array of them's) candidate targets
    /// and `vpiExpr` (37.29 detail 1).
    fn vif_details(&mut self, sym: &Symbol<'_>, first: ObjId, last: ObjId) {
        let Some(ty) = sym.value_type() else { return };
        let mut elem = ty.canonical();
        while elem.is_unpacked_array()
            && let Some(e) = elem.element_type()
        {
            elem = e.canonical();
        }
        let Some(VifShape { def, modport, .. }) = vif_shape(&elem) else {
            return;
        };
        let targets: Vec<String> = vj_sim::netlist::vif::interface_instances(sym, &def)
            .iter()
            .map(|i| match &modport {
                Some(m) => format!("{}.{m}", i.hierarchical_path()),
                None => i.hierarchical_path(),
            })
            .collect();
        let init = sym
            .initializer()
            .and_then(|e| {
                e.referenced_symbol().or_else(|| {
                    e.as_sem_node()
                        .children()
                        .into_iter()
                        .find_map(|n| n.as_expression())
                        .and_then(|x| x.referenced_symbol())
                })
            })
            .map(|s| s.hierarchical_path());
        for id in first..last {
            if self.model.get(id).map(|o| o.kind) != Some(ObjKind::VirtualInterfaceVar) {
                continue;
            }
            if let Some(p) = self.model.props_mut(id) {
                p.vif_targets = Some(targets.clone());
                p.is_modport = modport.is_some();
            }
            if let Some(path) = &init {
                let path = match &modport {
                    Some(m) if !path.ends_with(&format!(".{m}")) => format!("{path}.{m}"),
                    _ => path.clone(),
                };
                self.path_links.push((id, consts::VPI_EXPR, path));
            }
        }
    }

    /// The user-defined nettype `sym`, a net, is declared with (6.6.7): the
    /// `NetType` symbol its declaration's type name finds up its scopes.
    fn user_nettype_of<'d>(&self, sym: &Symbol<'d>) -> Option<Symbol<'d>> {
        let (name, _) = crate::usernets::declared_type_name(sym, &self.locator.syntax_trees())?;
        let name = name.rsplit("::").next().unwrap_or(&name).to_owned();
        Self::nettype_named(sym.parent()?, &name)
    }

    /// The user-defined nettype `name` as seen from `scope` (its members, then
    /// the enclosing scopes', then the compilation units').
    fn nettype_named<'d>(scope: Symbol<'d>, name: &str) -> Option<Symbol<'d>> {
        let mut at = Some(scope);
        while let Some(sc) = at {
            if let Some(m) = sc.members().find(|m| {
                m.kind() == SymbolKind::NetType && !m.net_type_is_built_in() && m.name() == name
            }) {
                return Some(m);
            }
            at = sc.parent();
        }
        None
    }

    /// A user-defined nettype declaration (37.23).
    fn nettype_decl(&mut self, sym: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        let name = sym.name().to_owned();
        let full = format!("{parent_name}.{name}");
        let mut obj = Obj::new(ObjKind::NettypeDecl, Some(parent), &name, &full);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(sym);
        let id = self.add(obj);
        // `nettype <nettype> <name>;` renames a nettype (6.6.7 detail 2).
        let target = crate::usernets::alias_target(sym, &self.locator.syntax_trees());
        let alias = target
            .as_deref()
            .and_then(|t| Self::nettype_named(sym.parent()?, t.rsplit("::").next().unwrap_or(t)))
            .filter(|t| t.uid() != sym.uid());
        if let Some(a) = alias {
            self.path_links
                .push((id, header("vpiNetTypedefAlias"), a.hierarchical_path()));
        }
        self.typespec_rel(id, sym.declared_type());
        // An alias is the same nettype (6.6.7): the renamed one's function.
        let mut func = sym.net_type_resolution_function();
        let mut next = alias;
        for _ in 0..32 {
            let Some(n) = next.filter(|_| func.is_none()) else {
                break;
            };
            func = n.net_type_resolution_function();
            next = crate::usernets::alias_target(&n, &self.locator.syntax_trees())
                .and_then(|t| Self::nettype_named(n.parent()?, t.rsplit("::").next().unwrap_or(&t)))
                .filter(|t| t.uid() != n.uid());
        }
        if let Some(f) = func {
            self.path_links
                .push((id, header("vpiWith"), f.hierarchical_path()));
        }
    }

    /// The element objects of the fixed-size unpacked array `arr_ty` (object
    /// `arr`, named `name`/`full`): a word per element of the innermost
    /// dimension and a nested array object per element of an outer one.
    /// `row` is the flat row of this sub-array's first word and `lower` the
    /// first dimension's lowest index (the memory slot's `lower_index`): a
    /// word's [`SigKey`] index is `lower + row` (`vj-codegen`'s
    /// `arrays` layout: row-major, each dimension's lowest index first).
    #[allow(clippy::too_many_arguments)]
    fn array_words(
        &mut self,
        arr_ty: &Type<'_>,
        arr: ObjId,
        name: &str,
        full: &str,
        row: i64,
        lower: i64,
        net: bool,
        line: i32,
        key: &dyn Fn(Option<i64>) -> SigKey,
    ) {
        let Some(elem) = arr_ty.canonical().element_type() else {
            return;
        };
        let range = arr_ty.canonical().fixed_range();
        let count = range.left.abs_diff(range.right) as usize + 1;
        let nested = elem.canonical().is_unpacked_array();
        // Rows one step of this dimension spans: the unpacked dimensions
        // below it (a packed element is a single row).
        let stride: i64 = if nested {
            Self::dims_of(&elem)
                .iter()
                .map(|&(l, r)| i64::from(l.abs_diff(r)) + 1)
                .product()
        } else {
            1
        };
        let Some((kind, width, signed, vector)) = self
            .model
            .get(arr)
            .map(|o| (o.kind, o.props.width, o.props.signed, o.props.vector))
        else {
            return;
        };
        for i in 0..count {
            let idx = element_index(range, i);
            let ename = format!("{name}[{idx}]");
            let efull = format!("{full}[{idx}]");
            // Rows run lowest index first within a dimension.
            let step = i64::from(idx - range.left.min(range.right));
            let erow = row + step * stride;
            if nested {
                let ec = elem.canonical();
                let inner = ec.fixed_range();
                let mut e = Obj::new(kind, Some(arr), &ename, &efull);
                e.props.size = Some((inner.left.abs_diff(inner.right) + 1) as i32);
                e.props.range = Some((inner.left, inner.right));
                e.props.dims = Self::dims_of(&ec);
                e.props.array_key = Some(key(None));
                e.props.index = Some(idx);
                e.props.width = width;
                e.props.vector = vector;
                e.props.signed = signed;
                e.props.file = Some(self.file.clone());
                e.props.line = line;
                let eid = self.add(e);
                self.typespec_rel(eid, Some(elem));
                self.array_words(&ec, eid, &ename, &efull, erow, lower, net, line, key);
                continue;
            }
            let mut e = Obj::new(Self::data_kind(&elem, net), Some(arr), &ename, &efull);
            Self::fill_scalar_props(&mut e.props, &elem);
            e.props.index = Some(idx);
            e.props.sig = Some(key(Some(lower + erow)));
            e.props.file = Some(self.file.clone());
            e.props.line = line;
            let eid = self.add(e);
            self.typespec_rel(eid, Some(elem));
            self.parts(&elem, eid, &ename, &efull, 0, net, line);
        }
    }

    /// The element shape of the queue, dynamic or associative array type
    /// `canon` (37.17): an element that is itself a collection nests its own
    /// shape; an element that is a fixed-size array has none.
    /// The member tree of a collection element of unpacked struct or
    /// untagged union type `ty` (`DynShape::members`): its integral, real,
    /// nested struct/union fields and one-dimensional fixed-size arrays of
    /// integral or real elements (rows lowest index first, as stored). Empty
    /// for any other element, or when a field cannot be named this way.
    fn struct_members(&mut self, ty: &Type<'_>) -> Vec<super::dynarr::MemberPart> {
        use vj_codegen::types::TypeWidth;
        use vj_sim::state::storage;
        let ty = ty.canonical();
        if !(ty.is_unpacked_struct() || ty.is_unpacked_union()) {
            return Vec::new();
        }
        // The stored element must be exactly its value bits.
        if storage::storage_width(&ty) != Some(u64::from(ty.value_width())) {
            return Vec::new();
        }
        let mut out = Vec::new();
        if self.push_members(&ty, 0, None, &mut out) {
            out
        } else {
            Vec::new()
        }
    }

    fn push_members(
        &mut self,
        ty: &Type<'_>,
        bit0: u32,
        parent: Option<u32>,
        out: &mut Vec<super::dynarr::MemberPart>,
    ) -> bool {
        use vj_codegen::types::TypeWidth;
        use vj_sim::state::storage;
        let scalar = |t: &Type<'_>| (t.is_integral() || t.is_floating()) && !t.is_unpacked_array();
        for f in ty.fields() {
            let (Some(fty), Some((lo, w))) =
                (f.value_type(), storage::field_slice(ty, f.field_index()))
            else {
                return false;
            };
            let fty = fty.canonical();
            // A `void` member of a tagged union carries no value bits.
            if fty.is_void() {
                continue;
            }
            let lo = bit0 + lo as u32;
            let nested = fty.is_unpacked_struct() || fty.is_unpacked_union();
            // The tag that makes this member the active one (7.3.2).
            let tag = match storage::tagged_tag_slice(ty) {
                Some((tlo, tw)) if tw > 0 => Some(super::dynarr::TagCond {
                    base: bit0,
                    payload: tlo as u32,
                    tag_lo: bit0 + tlo as u32,
                    tag_w: tw as u32,
                    value: f.field_index(),
                }),
                _ => None,
            };
            let elem = if fty.is_unpacked_array() && !fty.is_dynamically_sized_array() {
                fty.element_type().filter(|e| scalar(&e.canonical()))
            } else {
                None
            };
            if !nested && elem.is_none() && !scalar(&fty) {
                return false;
            }
            out.push(super::dynarr::MemberPart {
                name: f.name().to_owned(),
                kind: Self::data_kind(&fty, false),
                width: w as u32,
                signed: fty.is_signed(),
                lo,
                parent,
                index: None,
                typespec: self.typespec(&fty),
                tag,
            });
            let me = (out.len() - 1) as u32;
            if nested {
                if !self.push_members(&fty, lo, Some(me), out) {
                    return false;
                }
            } else if let Some(e) = elem {
                let range = fty.fixed_range();
                let ew = e.value_width().max(1);
                let count = range.left.abs_diff(range.right) + 1;
                if u64::from(ew) * u64::from(count) != w {
                    return false;
                }
                let low = range.left.min(range.right);
                // Rows are stored lowest index first but iterate left bound
                // first (as the elements of any unpacked array).
                let step = if range.left <= range.right { 1 } else { -1 };
                for k in 0..count {
                    let idx = i64::from(range.left) + i64::from(step) * i64::from(k);
                    let r = (idx - i64::from(low)) as u32;
                    out.push(super::dynarr::MemberPart {
                        name: format!("[{idx}]"),
                        kind: Self::data_kind(&e, false),
                        width: ew,
                        signed: e.is_signed(),
                        lo: lo + r * ew,
                        parent: Some(me),
                        index: Some(idx),
                        typespec: self.typespec(&e),
                        tag: None,
                    });
                }
            }
        }
        true
    }

    fn dyn_shape(&mut self, canon: &Type<'_>) -> Option<super::dynarr::DynShape> {
        use vj_codegen::types::TypeWidth;
        let elem = canon.element_type()?;
        let obj_elems = elem.canonical().is_class();
        let width = if obj_elems {
            64
        } else {
            elem.value_width().max(1)
        };
        let key = if canon.is_associative_array() {
            match canon.associative_index_type() {
                Some(k) if k.is_string() => vj_sim::collections::KeyKind::Str,
                Some(k) => vj_sim::collections::KeyKind::Int {
                    width: k.value_width().max(1),
                    signed: k.is_signed(),
                },
                None => vj_sim::collections::KeyKind::Int {
                    width: 64,
                    signed: false,
                },
            }
        } else {
            vj_sim::collections::KeyKind::Int {
                width: 32,
                signed: true,
            }
        };
        let elem_typespec = self.typespec(&elem);
        let inner = if vj_sim::state::storage::is_collection(&elem.canonical()) {
            self.dyn_shape(&elem.canonical()).map(Box::new)
        } else {
            None
        };
        // A one-dimensional fixed-size array of integral elements: its
        // elements are addressed through one more key (`FixedElems`).
        let ec = elem.canonical();
        let fixed = if ec.is_unpacked_array() && !ec.is_dynamically_sized_array() {
            ec.element_type()
                .filter(|e| e.canonical().is_integral())
                .map(|e| {
                    let range = ec.fixed_range();
                    super::dynarr::FixedElems {
                        left: range.left,
                        right: range.right,
                        elem_kind: Self::data_kind(&e, false),
                        width: e.value_width().max(1),
                        signed: e.is_signed(),
                        elem_typespec: self.typespec(&e),
                    }
                })
        } else {
            None
        };
        let members = self.struct_members(&ec);
        Some(super::dynarr::DynShape {
            members,
            fixed,
            elem_kind: Self::data_kind(&elem, false),
            width,
            signed: elem.is_signed(),
            assoc: canon.is_associative_array(),
            queue: canon.is_queue(),
            key,
            obj: obj_elems,
            elem_typespec,
            inner,
        })
    }

    fn data_objects(&mut self, sym: &Symbol<'_>, parent: ObjId, parent_name: &str, net: bool) {
        let Some(ty) = sym.value_type() else { return };
        let Some(body) = self.body.clone() else {
            return;
        };
        let name = sym.name().to_owned();
        if name.is_empty() {
            return;
        }
        let full = format!("{parent_name}.{name}");
        let key = |index: Option<i64>| SigKey {
            body: body.clone(),
            sym: sym.uid(),
            index,
        };
        let key_of = key;
        let line = self.locator.line(sym);
        let canon = ty.canonical();
        // A queue, dynamic or associative array (37.17): an array var whose
        // size and elements are the live collection's (`super::dynarr`).
        if vj_sim::state::storage::is_collection(&canon) && !net {
            let Some(shape) = self.dyn_shape(&canon) else {
                return;
            };
            let width = shape.width;
            let elem = canon.element_type().expect("a collection");
            let mut obj = Obj::new(ObjKind::RegArray, Some(parent), &name, &full);
            obj.props.array_type = header(if canon.is_associative_array() {
                "vpiAssocArray"
            } else if canon.is_queue() {
                "vpiQueueArray"
            } else {
                "vpiDynamicArray"
            });
            obj.props.dyn_elem = Some(shape);
            obj.props.width = width as i32;
            obj.props.signed = elem.is_signed();
            obj.props.sig = Some(key_of(None));
            obj.props.file = Some(self.file.clone());
            obj.props.line = line;
            let id = self.add(obj);
            self.attributes(sym.attributes(), id, &full, false);
            self.typespec_rel(id, Some(ty));
            return;
        }
        if canon.is_unpacked_array() && !canon.is_dynamically_sized_array() {
            let Some(elem) = canon.element_type() else {
                return;
            };
            let range = canon.fixed_range();
            let count = range.left.abs_diff(range.right) as usize + 1;
            let mut obj = Obj::new(
                if net {
                    ObjKind::NetArray
                } else if elem.canonical().is_event() {
                    ObjKind::NamedEventArray
                } else {
                    ObjKind::RegArray
                },
                Some(parent),
                &name,
                &full,
            );
            obj.props.size = Some(count as i32);
            obj.props.range = Some((range.left, range.right));
            obj.props.dims = Self::dims_of(&canon);
            obj.props.array_key = Some(key(None));
            obj.props.width = elem.bit_width() as i32;
            obj.props.vector = Self::elem_is_vector(&elem);
            obj.props.signed = elem.is_signed();
            obj.props.file = Some(self.file.clone());
            obj.props.line = line;
            let id = self.add(obj);
            // The array's initialization expression (37.17 detail 8).
            if !net
                && let Some(init) = sym.initializer()
                && let Some(op) = self.operand(&init)
            {
                self.rel(id, consts::VPI_EXPR, op);
            }
            self.attributes(sym.attributes(), id, &full, false);
            self.typespec_rel(id, Some(ty));
            // One object per element; a very large memory keeps only its
            // array object (its elements are not addressable by VPI). A
            // multidimensional array nests: each element of the outer array
            // is an array object of the next dimension (37.17), and the
            // innermost words address the flat row-major memory.
            let total = Self::dims_of(&canon)
                .iter()
                .map(|&(l, r)| l.abs_diff(r) as usize + 1)
                .product::<usize>();
            if count > MAX_ELEMENTS || total > MAX_ELEMENTS {
                return;
            }
            let lower = i64::from(range.left.min(range.right));
            self.array_words(&canon, id, &name, &full, 0, lower, net, line, &key);
            return;
        }
        let mut obj = Obj::new(Self::data_kind(&ty, net), Some(parent), &name, &full);
        Self::fill_scalar_props(&mut obj.props, &ty);
        if net {
            // sv-lang exposes a net's kind only through its declaration's
            // keyword (`crate::nets::net_kind_of` reads it from the syntax).
            obj.props.net_type =
                net_type_const(crate::nets::net_kind_of(sym, &self.locator.syntax_trees()));
        }
        if net {
            obj.props.expansion_hint =
                match crate::nets::expansion_hint_of(sym, &self.locator.syntax_trees()) {
                    Some(true) => 1,
                    Some(false) => 2,
                    None => 0,
                };
            // 37.16 detail 9: an implicit net has no declaration line.
            obj.props.implicit = sym.net_is_implicit();
        }
        obj.props.sig = Some(key(None));
        obj.props.const_var = sym.variable_flags().contains(sv_lang::VariableFlags::CONST);
        obj.props.cont_driven = vj_codegen::force::continuously_driven(sym);
        obj.props.file = Some(self.file.clone());
        obj.props.line = if obj.props.implicit { 0 } else { line };
        let id = self.add(obj);
        // A variable's initialization expression (37.17 detail 8). A virtual
        // interface variable's `vpiExpr` is the interface (or modport) instance
        // it is initialised to, linked by path in `vif_targets` (37.29); the
        // generic operand of the same initializer would shadow that link.
        if !net
            && self.model.get(id).map(|o| o.kind) != Some(ObjKind::VirtualInterfaceVar)
            && let Some(init) = sym.initializer()
            && let Some(op) = self.operand(&init)
        {
            self.rel(id, consts::VPI_EXPR, op);
        }
        self.attributes(sym.attributes(), id, &full, false);
        self.typespec_rel(id, Some(ty));
        if canon.is_packed_array() {
            self.range_exprs(sym, id);
        }
        self.parts(&ty, id, &name, &full, 0, net, line);
    }

    /// The parts of a value of type `ty` stored at bits `base..` of its
    /// root object's value, as children of `owner` (named `owner_name`):
    /// a struct's or union's members (37.26) or a packed array's elements
    /// (37.18), each again with its own parts. A part has no `sig` of its
    /// own: it is read and written through its root's (`Props::field`).
    #[allow(clippy::too_many_arguments)]
    fn parts(
        &mut self,
        ty: &Type<'_>,
        owner: ObjId,
        owner_name: &str,
        owner_full: &str,
        base: u32,
        net: bool,
        line: i32,
    ) {
        let canon = ty.canonical();
        if Self::packed_array_objects(&canon) {
            let Some(elem) = canon.element_type() else {
                return;
            };
            let range = canon.fixed_range();
            let count = range.left.abs_diff(range.right) as usize + 1;
            if count > MAX_ELEMENTS {
                return;
            }
            let ew = elem.bit_width() as u32;
            for i in 0..count {
                let idx = element_index(range, i);
                // The rightmost index is the least significant element.
                let lsb = base + (idx - range.right).unsigned_abs() * ew;
                let name = format!("{owner_name}[{idx}]");
                let full = format!("{owner_full}[{idx}]");
                let mut e = Obj::new(Self::data_kind(&elem, net), Some(owner), &name, &full);
                Self::fill_scalar_props(&mut e.props, &elem);
                e.props.index = Some(idx);
                e.props.field = Some((lsb, ew));
                e.props.packed_member = true;
                e.props.file = Some(self.file.clone());
                e.props.line = line;
                let id = self.add(e);
                self.typespec_rel(id, Some(elem));
                self.parts(&elem, id, &name, &full, lsb, net, line);
            }
            return;
        }
        if !(canon.is_struct() || canon.is_packed_union() || canon.is_unpacked_union()) {
            return;
        }
        let unpacked = vj_sim::state::storage::is_unpacked_aggregate(&canon);
        for f in canon.fields() {
            let Some(fty) = f.value_type() else { continue };
            let slice = if unpacked {
                vj_sim::state::storage::field_slice(&canon, f.field_index())
            } else {
                Some((f.field_bit_offset(), fty.bit_width()))
            };
            let Some((lo, w)) = slice else { continue };
            let lsb = base + lo as u32;
            let name = f.name().to_owned();
            let full = format!("{owner_full}.{name}");
            let fc = fty.canonical();
            // A fixed-size unpacked array member: its elements, lowest index
            // least significant (`storage`).
            if fc.is_unpacked_array() && !fc.is_dynamically_sized_array() {
                let Some(elem) = fc.element_type() else {
                    continue;
                };
                let Some(ew) = vj_sim::state::storage::storage_width(&elem) else {
                    continue;
                };
                let range = fc.fixed_range();
                let count = range.left.abs_diff(range.right) as usize + 1;
                let mut a = Obj::new(
                    if net {
                        ObjKind::NetArray
                    } else {
                        ObjKind::RegArray
                    },
                    Some(owner),
                    &name,
                    &full,
                );
                a.props.size = Some(count as i32);
                a.props.range = Some((range.left, range.right));
                a.props.width = elem.bit_width() as i32;
                a.props.vector = Self::elem_is_vector(&elem);
                a.props.signed = elem.is_signed();
                a.props.member = true;
                a.props.dims = Self::dims_of(&fc);
                a.props.file = Some(self.file.clone());
                a.props.line = line;
                let aid = self.add(a);
                self.typespec_rel(aid, Some(fty));
                if count > MAX_ELEMENTS || elem.is_unpacked_array() {
                    continue;
                }
                let low = range.left.min(range.right);
                for i in 0..count {
                    let idx = element_index(range, i);
                    let elsb = lsb + (idx - low) as u32 * ew as u32;
                    let ename = format!("{name}[{idx}]");
                    let efull = format!("{full}[{idx}]");
                    let mut e = Obj::new(Self::data_kind(&elem, net), Some(aid), &ename, &efull);
                    Self::fill_scalar_props(&mut e.props, &elem);
                    e.props.index = Some(idx);
                    e.props.field = Some((elsb, ew as u32));
                    e.props.file = Some(self.file.clone());
                    e.props.line = line;
                    let eid = self.add(e);
                    self.typespec_rel(eid, Some(elem));
                    self.parts(&elem, eid, &ename, &efull, elsb, net, line);
                }
                continue;
            }
            let mut m = Obj::new(Self::data_kind(&fty, net), Some(owner), &name, &full);
            Self::fill_scalar_props(&mut m.props, &fty);
            m.props.field = Some((lsb, w as u32));
            m.props.member = true;
            m.props.file = Some(self.file.clone());
            m.props.line = line;
            let id = self.add(m);
            self.typespec_rel(id, Some(fty));
            self.parts(&fty, id, &name, &full, lsb, net, line);
        }
    }

    /// Whether an array element of type `elem` is a vector (37.16 detail 28).
    fn elem_is_vector(elem: &Type<'_>) -> bool {
        let canon = elem.canonical();
        canon.is_packed_array() || (canon.is_integral() && canon.bit_width() > 1)
    }

    fn fill_scalar_props(p: &mut Props, ty: &Type<'_>) {
        let canon = ty.canonical();
        p.packed = (canon.is_struct() && !canon.is_unpacked_struct())
            || canon.is_packed_union()
            || canon.is_enum()
            || Self::packed_array_objects(&canon);
        p.tagged = (canon.is_packed_union() && canon.packed_union_is_tagged())
            || (canon.is_unpacked_union() && canon.unpacked_union_is_tagged());
        p.soft = canon.is_packed_union() && canon.packed_union_is_soft();
        if vj_sim::state::storage::is_unpacked_aggregate(&canon) {
            p.members = Some(canon.fields().count() as i32);
        }
        p.width = canon.bit_width() as i32;
        p.signed = canon.is_signed();
        p.vector = canon.is_packed_array() || (canon.is_integral() && canon.bit_width() > 1);
        if canon.is_packed_array() {
            let r = canon.fixed_range();
            p.range = Some((r.left, r.right));
            p.dims = Self::dims_of(&canon);
        } else if canon.is_integral() && canon.bit_width() > 1 {
            p.range = Some((canon.bit_width() as i32 - 1, 0));
        }
    }

    /// A parameter or localparam with its value.
    /// The attribute instances `attrs` (37.83) as children of `owner`;
    /// `def`: they are on its definition, not on the object itself.
    fn attributes<'a>(
        &mut self,
        attrs: impl Iterator<Item = Symbol<'a>>,
        owner: ObjId,
        owner_full: &str,
        def: bool,
    ) {
        for a in attrs {
            let name = a.name().to_owned();
            let mut obj = Obj::new(
                ObjKind::Attribute,
                Some(owner),
                &name,
                &format!("{owner_full}.{name}"),
            );
            Self::fill_value(&mut obj.props, &a.attribute_value());
            obj.props.def_attribute = def;
            obj.props.file = Some(self.file.clone());
            obj.props.line = self.locator.line(&a);
            obj.props.def_file = Some(self.file.clone());
            obj.props.def_line = obj.props.line;
            self.add(obj);
        }
    }

    /// A process (37.63) and its statement tree.
    fn process(&mut self, block: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        use sv_lang::ProceduralBlockKind as P;
        let c = |n: &str| consts::value_of(n).expect("a header constant") as i32;
        let mut obj = Obj::new(ObjKind::Process, Some(parent), "", "");
        let (ty, always) = match block.procedural_block_procedure_kind() {
            P::Initial => (c("vpiInitial"), 0),
            P::Final => (c("vpiFinal"), 0),
            P::Always => (c("vpiAlways"), c("vpiAlways")),
            P::AlwaysComb => (c("vpiAlways"), c("vpiAlwaysComb")),
            P::AlwaysLatch => (c("vpiAlways"), c("vpiAlwaysLatch")),
            P::AlwaysFF => (c("vpiAlways"), c("vpiAlwaysFF")),
        };
        obj.props.stmt_type = ty;
        obj.props.always_type = always;
        obj.props.dyn_key = self.body.clone().map(|b| (b, block.uid()));
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(block);
        let id = self.add(obj);
        if let Some(body) = vj_sim::process::cfg::proc_body(block)
            && let Some(s) = self.stmt(&body, id, parent_name)
        {
            self.rel(id, consts::VPI_STMT, Operand::Obj(s));
        }
    }

    /// A block-local or subroutine-local variable (LRM 37.12 `vpiVariables`,
    /// `vpiReg`): the data object under `parent`. A static one shares the
    /// instance's STATE slot (6.21) and so has a value; an automatic one is
    /// lexical only (37.17 `vpiAutomatic`), its frame being per call.
    fn local_var(&mut self, sym: &Symbol<'_>, parent: ObjId, scope: &str) {
        let first = self.model.len() as ObjId;
        self.data(sym, parent, scope, false);
        let last = self.model.len() as ObjId;
        if sym.variable_lifetime() == VariableLifetime::Automatic {
            for id in first..last {
                if let Some(p) = self.model.props_mut(id) {
                    p.automatic = true;
                }
            }
        }
    }

    /// The variables declared directly in the scope symbol `scope_sym` (a
    /// statement block or subroutine), except `skip` (a function's result).
    fn scope_locals(
        &mut self,
        scope_sym: &Symbol<'_>,
        parent: ObjId,
        scope: &str,
        skip: Option<SymbolId>,
    ) {
        for m in scope_sym.members() {
            if m.kind() == SymbolKind::Variable && Some(m.uid()) != skip {
                self.local_var(&m, parent, scope);
            }
        }
    }

    /// An interface's `extern` (or `extern forkjoin`) task or function
    /// prototype (`vpiInterfaceTfDecl`, 37.8): its access type, and its
    /// implementations (in the instances its interface ports connect to) as
    /// its `vpiTask`/`vpiFunction` relations, linked after the build.
    fn interface_tf_decl(&mut self, proto: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        let Some(t) = vj_sim::netlist::itf::extern_targets(proto) else {
            return;
        };
        let name = proto.name().to_owned();
        let mut obj = Obj::new(
            ObjKind::InterfaceTfDecl,
            Some(parent),
            &name,
            &format!("{parent_name}.{name}"),
        );
        obj.props.access_type = header(if t.fork_join {
            "vpiForkJoinAcc"
        } else {
            "vpiExternAcc"
        });
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(proto);
        let id = self.add(obj);
        for imp in t.impls {
            let rel = match imp.subroutine_kind() {
                Some(sv_lang::SubroutineKind::Task) => header("vpiTask"),
                _ => header("vpiFunction"),
            };
            self.tf_rel_links.push((id, rel, imp.uid()));
        }
    }

    /// A task or function declaration (37.41) with its formals and body.
    /// `sep` joins the parent's name to the subroutine's: `.` in an instance,
    /// `::` in a package or class (37.41 detail 5).
    fn task_func(&mut self, sub: &Symbol<'_>, parent: ObjId, parent_name: &str, sep: &str) {
        let c = |n: &str| consts::value_of(n).expect("a header constant") as i32;
        let name = sub.name().to_owned();
        let full = format!("{parent_name}{sep}{name}");
        let mut obj = Obj::new(ObjKind::TaskFunc, Some(parent), &name, &full);
        let uid = sub.uid();
        obj.props.stmt_type = match sub.subroutine_kind() {
            Some(sv_lang::SubroutineKind::Task) => c("vpiTask"),
            _ => c("vpiFunction"),
        };
        obj.props.automatic =
            sub.subroutine_default_lifetime() == Some(VariableLifetime::Automatic);
        obj.props.virtual_ = sub.subroutine_is_virtual();
        // A method's `local`/`protected` qualifier (37.41 detail 4), read from
        // the words before `function`/`task` in its declaration.
        let quals = self
            .locator
            .trees
            .iter()
            .find_map(|(t, _)| sub.syntax(t))
            .map(|mut n| {
                // The qualifiers belong to the class method declaration
                // around the function declaration.
                if let Some(p) = n.parent()
                    && p.kind() == sv_lang::kinds::SyntaxKind::ClassMethodDeclaration
                {
                    n = p;
                }
                n.text().to_string()
            })
            .unwrap_or_default();
        let quals = quals
            .split(|ch: char| !(ch.is_alphanumeric() || ch == '_'))
            .take_while(|w| !matches!(*w, "function" | "task"))
            .collect::<Vec<_>>();
        obj.props.visibility = if quals.contains(&"local") {
            c("vpiLocalVis")
        } else if quals.contains(&"protected") {
            c("vpiProtectedVis")
        } else {
            0
        };
        obj.props.tf = Some(self.tf_info(sub, parent));
        let tf_obj_id = self.model.len() as ObjId;
        self.tf_by_uid.insert(uid, tf_obj_id);
        // A package subroutine has no enclosing body: the key's first half
        // is unused by the frame lookups (only the subroutine matters).
        obj.props.dyn_key = Some((self.body.clone().unwrap_or_else(|| sub.uid()), sub.uid()));
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(sub);
        let id = self.add(obj);
        self.attributes(sub.attributes(), id, &full, false);
        for arg in sub.subroutine_arguments() {
            let aname = arg.name().to_owned();
            let mut io = Obj::new(
                ObjKind::IODecl,
                Some(id),
                &aname,
                &format!("{full}.{aname}"),
            );
            io.props.direction = match arg.formal_argument_direction() {
                ArgumentDirection::In => consts::VPI_INPUT,
                ArgumentDirection::Out => consts::VPI_OUTPUT,
                ArgumentDirection::InOut => consts::VPI_INOUT,
                ArgumentDirection::Ref => consts::VPI_REF,
            };
            if let Some(ty) = arg.value_type() {
                io.props.width = ty.bit_width() as i32;
                io.props.signed = ty.is_signed();
            }
            io.props.file = Some(self.file.clone());
            io.props.line = self.locator.line(&arg);
            let io = self.add(io);
            self.typespec_rel(io, arg.value_type());
            // 37.15 detail 1: a `ref` formal is a ref obj, and a use of it in
            // the body (or a select of one) is that ref obj; its vpiActual is
            // bound per call (resolved at query time against the running
            // call).
            if arg.formal_argument_direction() == ArgumentDirection::Ref {
                let mut r = Obj::new(
                    ObjKind::RefObj,
                    Some(id),
                    &aname,
                    &format!("{full}.{aname}"),
                );
                if let Some(ty) = arg.value_type() {
                    r.props.width = ty.bit_width() as i32;
                    r.props.signed = ty.is_signed();
                    r.props.vector = ty.is_packed_array() || ty.bit_width() > 1;
                    let c = ty.canonical();
                    if c.is_packed_array() {
                        let rg = c.fixed_range();
                        r.props.range = Some((rg.left, rg.right));
                    } else if c.is_integral() && c.bit_width() > 1 {
                        r.props.range = Some((c.bit_width() as i32 - 1, 0));
                    }
                }
                r.props.file = Some(self.file.clone());
                r.props.line = self.locator.line(&arg);
                let rid = self.add(r);
                self.typespec_rel(rid, arg.value_type());
                self.tf_ref_by_uid.insert(arg.uid(), rid);
            }
        }
        // vpiReturn: always a variable, even for a simple return (37.42
        // details 2-3); a void function has none.
        if let Some(rv) = sub.subroutine_return_val_var()
            && let Some(ty) = rv.value_type()
            && !ty.canonical().is_void()
        {
            let mut v = Obj::new(
                Self::data_kind(&ty, false),
                Some(id),
                &name,
                &format!("{full}.{name}"),
            );
            Self::fill_scalar_props(&mut v.props, &ty);
            v.props.automatic = true;
            v.props.file = Some(self.file.clone());
            v.props.line = self.locator.line(sub);
            let v = self.add(v);
            self.typespec_rel(v, Some(ty));
            self.rel(id, header("vpiReturn"), Operand::Obj(v));
        }
        let result = sub.subroutine_return_val_var().map(|r| r.uid());
        self.scope_locals(sub, id, &full, result);
        // Its assertions and expect statements, which its statements refer to.
        self.assertions(sub, id, &full);
        // A body of several statements without `begin`/`end` is a list: each
        // statement is a `vpiStmt` of the task or function.
        if let Some(body) = vj_sim::process::cfg::proc_body(sub) {
            let mut items = Vec::new();
            Self::flat(&body, &mut items);
            for item in items {
                if let Some(s) = self.stmt(&item, id, &full) {
                    self.rel(id, consts::VPI_STMT, Operand::Obj(s));
                }
            }
        }
    }

    /// The elaboration-time properties of a task or function (37.41): the
    /// returned value's size and type (detail 12), whether it is a class
    /// method, and, for a DPI import, its qualifiers and C name (details
    /// 6-10), read from the declaration's source text.
    fn tf_info(&self, sub: &Symbol<'_>, parent: ObjId) -> TfInfo {
        let c = |n: &str| consts::value_of(n).expect("a header constant") as i32;
        let mut tf = TfInfo {
            method: self
                .model
                .get(parent)
                .is_some_and(|o| o.kind == ObjKind::ClassDefn),
            ..TfInfo::default()
        };
        if let Some(ty) = sub.subroutine_return_type() {
            let canon = ty.canonical();
            tf.size = if canon.is_void() {
                0
            } else {
                ty.bit_width() as i32
            };
            tf.signed = !canon.is_void() && ty.is_signed();
            // Only five function types exist (vpi_user.h): `real` and `time`
            // have their own, `integer`/`int` are integer functions, any
            // other value is sized (signed or not). A void function has no
            // value; it reads as sized with size 0.
            tf.func_type = if canon.is_floating() {
                c("vpiRealFunc")
            } else if canon.is_predefined_integer()
                && canon.predefined_integer_kind() == PredefinedIntegerKind::Time
            {
                c("vpiTimeFunc")
            } else if canon.is_predefined_integer()
                && matches!(
                    canon.predefined_integer_kind(),
                    PredefinedIntegerKind::Int | PredefinedIntegerKind::Integer
                )
            {
                c("vpiIntFunc")
            } else if tf.signed {
                c("vpiSizedSignedFunc")
            } else {
                c("vpiSizedFunc")
            };
        }
        if sub
            .subroutine_flags()
            .contains(sv_lang::MethodFlags::DPI_IMPORT)
        {
            tf.access = c("vpiDPIImportAcc");
            let text = self
                .locator
                .trees
                .iter()
                .find_map(|(t, _)| sub.syntax(t))
                .map(|n| n.text().to_string())
                .unwrap_or_default();
            let d = parse_dpi_import(&text, sub.name());
            tf.dpi_pure = d.pure;
            tf.dpi_context = d.context;
            tf.dpi_cstr = c(if d.spec == "DPI" { "vpiDPI" } else { "vpiDPIC" });
            tf.dpi_ident = Some(d.ident);
        }
        tf
    }

    /// Marks the subroutines the design exports to C (`export "DPI-C"`,
    /// 37.41 details 6, 9-10).
    fn dpi_exports(&mut self, design: &Design) {
        let c = |n: &str| consts::value_of(n).expect("a header constant") as i32;
        for e in design.dpi_exports() {
            let Some(&id) = self.tf_by_uid.get(&e.subroutine().uid()) else {
                continue;
            };
            let spec = self
                .locator
                .trees
                .iter()
                .find_map(|(t, _)| e.syntax(t))
                .map(|n| n.text().to_string())
                .and_then(|t| t.split('"').nth(1).map(str::to_owned))
                .unwrap_or_else(|| "DPI-C".to_owned());
            if let Some(tf) = self.model.props_mut(id).and_then(|p| p.tf.as_mut()) {
                tf.access = c("vpiDPIExportAcc");
                tf.dpi_cstr = c(if spec == "DPI" { "vpiDPI" } else { "vpiDPIC" });
                tf.dpi_ident = Some(e.c_identifier());
            }
        }
    }

    /// Appends the relation `(kind, target)` to object `id`.
    fn rel(&mut self, id: ObjId, kind: i32, target: Operand) {
        if let Some(p) = self.model.props_mut(id) {
            p.rels.push((kind, target));
        }
    }

    /// A pattern (37.72) as `parent`'s child: a constant pattern is its
    /// expression; `.*` and `.v` are `vpiAnyPattern`s (named by the
    /// variable); `tagged M p` a `vpiTaggedPattern` named `M` with `p` as its
    /// `vpiPattern`; `'{...}` a `vpiStructPattern` whose member patterns are
    /// its `vpiPattern`s, each named by its member when the pattern names it.
    fn pattern(&mut self, p: &sv_lang::Pattern<'_>, parent: ObjId) -> Option<Operand> {
        use sv_lang::kinds::PatternKind as P;
        let c = |n: &str| consts::value_of(n).expect("a header constant") as i32;
        let (ty, name) = match p.kind() {
            P::Constant => return p.value_expr().and_then(|e| self.operand(&e)),
            P::Wildcard => (c("vpiAnyPattern"), String::new()),
            P::Variable => (
                c("vpiAnyPattern"),
                p.variable()
                    .map(|v| v.name().to_owned())
                    .unwrap_or_default(),
            ),
            P::Tagged => (
                c("vpiTaggedPattern"),
                self.pattern_shape(p)
                    .and_then(|(t, _)| t)
                    .unwrap_or_default(),
            ),
            P::Structure => (c("vpiStructPattern"), String::new()),
            other => {
                return Some(Operand::Expr(
                    self.model
                        .add_expr(ExprNode::Unsupported(format!("a {other:?} pattern"))),
                ));
            }
        };
        let mut obj = Obj::new(ObjKind::Pattern, Some(parent), &name, "");
        obj.props.stmt_type = ty;
        obj.props.file = Some(self.file.clone());
        let id = self.add(obj);
        let kids: Vec<sv_lang::Pattern<'_>> = p
            .children()
            .into_iter()
            .filter_map(|n| n.as_pattern())
            .collect();
        let names = self
            .pattern_shape(p)
            .and_then(|(_, s)| s)
            .unwrap_or_default();
        for (k, kid) in kids.iter().enumerate() {
            if let Some(op) = self.pattern(kid, id) {
                if let (Operand::Obj(o), Some(Some(n))) = (op, names.get(k)) {
                    self.model.set_name(o, n);
                }
                self.rel(id, header("vpiPattern"), op);
            }
        }
        Some(Operand::Obj(id))
    }

    /// The member a tagged pattern names, or the member names of a structure
    /// pattern (`None` per positional member), from its syntax.
    #[allow(clippy::type_complexity)]
    fn pattern_shape(
        &self,
        p: &sv_lang::Pattern<'_>,
    ) -> Option<(Option<String>, Option<Vec<Option<String>>>)> {
        use sv_lang::AstNode;
        use sv_lang::nodes::{
            ParenthesizedPatternSyntax, StructurePatternMemberSyntax, StructurePatternSyntax,
            TaggedPatternSyntax,
        };
        for tree in self.locator.syntax_trees() {
            let Some(mut node) = p.syntax(&tree) else {
                continue;
            };
            while let Some(paren) = ParenthesizedPatternSyntax::cast(node) {
                node = paren.pattern().syntax();
            }
            if let Some(t) = TaggedPatternSyntax::cast(node) {
                return Some((t.member_name().map(|m| m.text().to_string()), None));
            }
            if let Some(s) = StructurePatternSyntax::cast(node) {
                let names = s
                    .members()
                    .iter()
                    .map(|m| match m {
                        StructurePatternMemberSyntax::NamedStructurePatternMember(n) => {
                            n.name().map(|t| t.text().to_string())
                        }
                        StructurePatternMemberSyntax::OrderedStructurePatternMember(_) => None,
                    })
                    .collect();
                return Some((None, Some(names)));
            }
            return None;
        }
        None
    }

    /// The statements a statement stands for: a list's items (flattened),
    /// anything else itself.
    fn flat<'d>(s: &sv_lang::Statement<'d>, out: &mut Vec<sv_lang::Statement<'d>>) {
        if s.kind() == sv_lang::kinds::StatementKind::List {
            for c in vj_sim::process::cfg::live_statements(s) {
                Self::flat(&c, out);
            }
        } else {
            out.push(*s);
        }
    }

    /// The object of statement `st` (37.60-37.79), a child of `parent`, with
    /// its sub-statements and expressions; `scope` is the full name of the
    /// enclosing named scope. `None` for what is not a VPI statement (a
    /// variable declaration) or not modelled (a randcase, randsequence,
    /// pattern case or procedural checker).
    /// The delay, event or repeat control object of an intra-assignment
    /// timing control (37.64), a child of the assignment `parent`.
    fn timing_control_obj(
        &mut self,
        tc: &sv_lang::TimingControl<'_>,
        parent: ObjId,
        line: i32,
    ) -> Option<ObjId> {
        use sv_lang::kinds::TimingControlKind as T;
        let c = |n: &str| consts::value_of(n).expect("a header constant") as i32;
        let (ty, rel) = match tc.kind() {
            T::Delay | T::Delay3 | T::OneStepDelay | T::CycleDelay => {
                (c("vpiDelayControl"), consts::VPI_DELAY)
            }
            T::RepeatedEvent => (c("vpiRepeatControl"), consts::VPI_CONDITION),
            _ => (c("vpiEventControl"), consts::VPI_CONDITION),
        };
        let scope = self.model.get(parent).map(|o| o.full_name.clone())?;
        let mut obj = Obj::new(ObjKind::Stmt, Some(parent), "", "");
        obj.props.stmt_type = ty;
        obj.props.file = Some(self.file.clone());
        obj.props.line = line;
        let id = self.add(obj);
        let e = tc.children().into_iter().find_map(|n| n.as_expression());
        let edge = (tc.kind() == T::SignalEvent)
            .then(|| match tc.edge() {
                sv_lang::EdgeKind::PosEdge => Some(c("vpiPosedgeOp")),
                sv_lang::EdgeKind::NegEdge => Some(c("vpiNegedgeOp")),
                _ => None,
            })
            .flatten();
        let _ = scope;
        if let Some(sig) = e
            && let Some(operand) = self.operand(&sig)
        {
            let op = match edge {
                Some(op_type) => Operand::Expr(self.model.add_expr(ExprNode::Op {
                    op_type,
                    width: 1,
                    operands: vec![operand],
                    meta: OpMeta::default(),
                })),
                None => operand,
            };
            self.rel(id, rel, op);
        }
        Some(id)
    }

    /// `v = init` as the `vpiAssignment` statement a declaration initializer
    /// stands for (37.74 `vpiForInitStmt`), a child of `parent`.
    fn var_init_stmt(
        &mut self,
        var: ObjId,
        init: &sv_lang::Expression<'_>,
        parent: ObjId,
    ) -> Option<ObjId> {
        let (file, line) = self
            .model
            .get(parent)
            .map(|o| (o.props.file.clone(), o.props.line))?;
        let mut obj = Obj::new(ObjKind::Stmt, Some(parent), "", "");
        obj.props.stmt_type = consts::value_of("vpiAssignment").expect("a header constant") as i32;
        obj.props.blocking = true;
        obj.props.op_type = consts::value_of("vpiAssignmentOp").expect("a header constant") as i32;
        obj.props.file = file;
        obj.props.line = line;
        let id = self.add(obj);
        self.rel(id, consts::VPI_LHS, Operand::Obj(var));
        if let Some(op) = self.operand(init) {
            self.rel(id, consts::VPI_RHS, op);
        }
        Some(id)
    }

    /// One initializer or step of a `for` header as the statement the LRM
    /// models it as (37.74 `vpiForInitStmt`/`vpiForIncStmt` are `stmt`s): a
    /// `vpiAssignment` for `t = 0`, `t += 2` and `t++`. `None` for any other
    /// expression (the caller keeps the plain expression).
    fn for_clause_stmt(&mut self, e: &sv_lang::Expression<'_>, parent: ObjId) -> Option<ObjId> {
        use sv_lang::kinds::ExpressionKind as K;
        if !matches!(e.kind(), K::Assignment | K::UnaryOp) {
            return None;
        }
        let (file, line) = self
            .model
            .get(parent)
            .map(|o| (o.props.file.clone(), o.props.line))?;
        let mut obj = Obj::new(ObjKind::Stmt, Some(parent), "", "");
        obj.props.stmt_type = consts::value_of("vpiAssignment").expect("a header constant") as i32;
        obj.props.file = file;
        obj.props.line = line;
        let id = self.add(obj);
        if e.kind() == K::Assignment {
            let op = compound_assign_op(e);
            if let Some(p) = self.model.props_mut(id) {
                p.blocking = e.is_nonblocking() != Some(true);
                p.op_type = op.unwrap_or(
                    consts::value_of("vpiAssignmentOp").expect("a header constant") as i32,
                );
            }
            for (rel, side) in [
                (consts::VPI_LHS, e.left()),
                (consts::VPI_RHS, assign_rhs(e)),
            ] {
                if let Some(op) = side.and_then(|s| self.operand(&s)) {
                    self.rel(id, rel, op);
                }
            }
        } else {
            if let Some(p) = self.model.props_mut(id) {
                p.blocking = true;
                p.op_type = op_type_of(e).unwrap_or(0);
            }
            if let Some(op) = e.operands().first().and_then(|s| self.operand(s)) {
                self.rel(id, consts::VPI_LHS, op);
            }
        }
        Some(id)
    }

    fn stmt(&mut self, st: &sv_lang::Statement<'_>, parent: ObjId, scope: &str) -> Option<ObjId> {
        use sv_lang::kinds::StatementKind as S;
        use sv_lang::kinds::TimingControlKind as T;
        let c = |n: &str| consts::value_of(n).expect("a header constant") as i32;
        // A statement inside a statically dead `if`/`case` arm slang could not
        // bind arrives wrapped in Invalid; model the real one (LRM 12.4/12.5).
        let st = &vj_sim::process::cfg::unwrap_invalid(*st);
        if st.kind() == S::List {
            let mut items = Vec::new();
            Self::flat(st, &mut items);
            // A list of one statement is that statement; a longer one (a
            // block's body) is handled by the block.
            return match items.as_slice() {
                [one] => self.stmt(one, parent, scope),
                _ => None,
            };
        }
        // `label: stmt` and `foreach`/`for` scopes arrive as an implicit block
        // around the one statement written (no `begin`): 37.60 detail 1 makes
        // the label that statement's `vpiName`, and the wrapper is no object.
        // The implicit scope around `for (int i = 0, ...)` holds the loop
        // variables' declarations and the one `for`; it is no object: 37.74
        // gives the `for` those declarations itself (`vpiLocalVarDecls`).
        if st.kind() == S::Block && !self.locator.is_begin_block(st) {
            let mut items = Vec::new();
            for s in vj_sim::process::cfg::live_statements(st) {
                Self::flat(&s, &mut items);
            }
            if let Some((last, decls)) = items.split_last()
                && last.kind() == S::ForLoop
                && !last.for_loop_vars().is_empty()
                && decls.iter().all(|d| d.kind() == S::VariableDeclaration)
            {
                return self.stmt(last, parent, scope);
            }
        }
        if st.kind() == S::Block && !self.locator.is_begin_block(st) {
            let mut items = Vec::new();
            for s in vj_sim::process::cfg::live_statements(st) {
                Self::flat(&s, &mut items);
            }
            if let [one] = items.as_slice() {
                let label = st
                    .block_symbol()
                    .map(|b| b.name().to_owned())
                    .filter(|n| !n.is_empty());
                let id = self.stmt(one, parent, scope)?;
                if let Some(l) = label {
                    self.model.set_name(id, &l);
                }
                return Some(id);
            }
        }
        if matches!(st.kind(), S::ImmediateAssertion | S::ConcurrentAssertion) {
            return self
                .assertion_ids
                .get(&st.source_range().start.offset)
                .copied();
        }
        let mut name = String::new();
        let mut full = String::new();
        let ty = match st.kind() {
            S::Empty => c("vpiNullStmt"),
            S::Block => {
                let named = st
                    .block_symbol()
                    .map(|b| b.name().to_owned())
                    .filter(|n| !n.is_empty());
                let fork = st.block_kind() != Some(sv_lang::StatementBlockKind::Sequential);
                if let Some(n) = named {
                    full = format!("{scope}.{n}");
                    name = n;
                }
                match (fork, name.is_empty()) {
                    (false, true) => c("vpiBegin"),
                    (false, false) => c("vpiNamedBegin"),
                    (true, true) => c("vpiFork"),
                    (true, false) => c("vpiNamedFork"),
                }
            }
            S::ExpressionStatement => {
                let e = st.expr()?;
                match e.kind() {
                    sv_lang::kinds::ExpressionKind::Assignment => c("vpiAssignment"),
                    sv_lang::kinds::ExpressionKind::Call => {
                        let builtin = e.system_subroutine().filter(|m| !m.name().starts_with('$'));
                        if let Some(m) = builtin {
                            c(if m.is_task() {
                                "vpiMethodTaskCall"
                            } else {
                                "vpiMethodFuncCall"
                            })
                        } else if e.call_this_class().is_some() {
                            let task = e.call_subroutine().and_then(|s| s.subroutine_kind())
                                == Some(sv_lang::SubroutineKind::Task);
                            c(if task {
                                "vpiMethodTaskCall"
                            } else {
                                "vpiMethodFuncCall"
                            })
                        } else if e.is_system_call() == Some(true) {
                            c("vpiSysTaskCall")
                        } else {
                            c("vpiTaskCall")
                        }
                    }
                    sv_lang::kinds::ExpressionKind::UnaryOp => c("vpiAssignment"),
                    _ => return None,
                }
            }
            S::Conditional if st.else_branch().is_some() => c("vpiIfElse"),
            S::Conditional => c("vpiIf"),
            S::Case | S::PatternCase => c("vpiCase"),
            S::ForLoop => c("vpiFor"),
            S::RepeatLoop => c("vpiRepeat"),
            S::ForeachLoop => c("vpiForeachStmt"),
            S::WhileLoop => c("vpiWhile"),
            S::DoWhileLoop => c("vpiDoWhile"),
            S::ForeverLoop => c("vpiForever"),
            S::Timed => match st.timing_control().map(|t| t.kind()) {
                Some(T::Delay | T::Delay3 | T::OneStepDelay | T::CycleDelay) => {
                    c("vpiDelayControl")
                }
                Some(T::RepeatedEvent) => c("vpiRepeatControl"),
                _ => c("vpiEventControl"),
            },
            S::Return => c("vpiReturnStmt"),
            S::Break => c("vpiBreak"),
            S::Continue => c("vpiContinue"),
            S::Disable => c("vpiDisable"),
            S::DisableFork => c("vpiDisableFork"),
            S::Wait => c("vpiWait"),
            S::WaitFork => c("vpiWaitFork"),
            S::WaitOrder => c("vpiOrderedWait"),
            S::EventTrigger => c("vpiEventStmt"),
            S::ProceduralAssign if st.procedural_assign_is_force() => c("vpiForce"),
            S::ProceduralAssign => c("vpiAssignStmt"),
            S::ProceduralDeassign if st.procedural_deassign_is_release() => c("vpiRelease"),
            S::ProceduralDeassign => c("vpiDeassign"),
            _ => return None,
        };
        let mut obj = Obj::new(ObjKind::Stmt, Some(parent), &name, &full);
        obj.props.stmt_type = ty;
        // 37.12: a fork's join type and whether a `for` declares its own
        // variables.
        obj.props.join_type = match st.block_kind() {
            Some(sv_lang::StatementBlockKind::JoinNone) => c("vpiJoinNone"),
            Some(sv_lang::StatementBlockKind::JoinAny) => c("vpiJoinAny"),
            _ => c("vpiJoin"),
        };
        obj.props.local_var_decls = st.kind() == S::ForLoop && !st.for_loop_vars().is_empty();
        // 37.71/37.72 `vpiQualifier`: `unique`/`priority` and `inside` (the
        // LRM names no value for `unique0`).
        if matches!(st.kind(), S::Conditional | S::Case | S::PatternCase) {
            use sv_lang::UniquePriorityCheck as U;
            let check = if st.kind() == S::PatternCase {
                st.pattern_case_check()
            } else {
                st.check()
            };
            let inside = i32::from(
                st.kind() == S::Case
                    && st.case_condition() == Some(sv_lang::CaseStatementCondition::Inside),
            ) * c("vpiInsideQualifier");
            obj.props.qualifier = match check {
                None | Some(U::None) => Some(c("vpiNoQualifier") | inside),
                Some(U::Unique) => Some(c("vpiUniqueQualifier") | inside),
                Some(U::Priority) => Some(c("vpiPriorityQualifier") | inside),
                Some(U::Unique0) => None,
            };
        }
        if st.kind() == S::EventTrigger {
            obj.props.blocking = st.is_nonblocking_trigger() == Some(false);
        }
        obj.props.stmt_key = Some(vj_codegen::vpi_dyn::key_of(st));
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.stmt_line(st);
        let obj_line = obj.props.line;
        let id = self.add(obj);
        self.attributes(
            st.attributes(),
            id,
            if full.is_empty() { scope } else { &full },
            false,
        );
        let inner = if full.is_empty() {
            scope.to_owned()
        } else {
            full.clone()
        };
        let sub = |b: &mut Self, rel: i32, s: Option<sv_lang::Statement<'_>>| {
            if let Some(s) = s
                && let Some(o) = b.stmt(&s, id, &inner)
            {
                b.rel(id, rel, Operand::Obj(o));
            }
        };
        let stmt_sites = if matches!(st.kind(), S::Block | S::List) || self.let_decls.is_empty() {
            Vec::new()
        } else {
            let trees = self.locator.syntax_trees();
            trees
                .iter()
                .find_map(|t| st.syntax(t))
                .map(|n| self.collect_let_sites(n))
                .unwrap_or_default()
        };
        let expr = |b: &mut Self, rel: i32, e: Option<sv_lang::Expression<'_>>| {
            if let Some(e) = e
                && {
                    b.stmt_sites = stmt_sites.clone();
                    true
                }
                && let Some(op) = b.operand(&e)
            {
                b.rel(id, rel, op);
            }
        };
        match st.kind() {
            S::Block => {
                if let Some(bs) = st.block_symbol() {
                    self.scope_locals(&bs, id, &inner, None);
                }
                let mut items = Vec::new();
                for s in vj_sim::process::cfg::live_statements(st) {
                    Self::flat(&s, &mut items);
                }
                for s in items {
                    sub(self, consts::VPI_STMT, Some(s));
                }
            }
            S::ExpressionStatement => {
                let e = st.expr()?;
                match e.kind() {
                    sv_lang::kinds::ExpressionKind::Assignment => {
                        let nb = e.is_nonblocking() == Some(true);
                        let op = compound_assign_op(&e);
                        if let Some(p) = self.model.props_mut(id) {
                            p.blocking = !nb;
                            p.op_type = op.unwrap_or(c("vpiAssignmentOp"));
                        }
                        expr(self, consts::VPI_LHS, e.left());
                        self.let_hint = Some(self.let_sites_of_expr(&e));
                        expr(self, consts::VPI_RHS, assign_rhs(&e));
                        self.let_hint = None;
                        // `a = #2 b;`, `a <= @(e) b;`, `a = repeat (n) @(e) b;`
                        // (37.64): the control hangs off the assignment.
                        if let Some(tc) = e.assignment_timing().and_then(|n| n.as_timing_control())
                            && let Some(ctl) = self.timing_control_obj(&tc, id, obj_line)
                        {
                            let rel = self.model.get(ctl).map_or(0, |o| o.props.stmt_type);
                            self.rel(id, rel, Operand::Obj(ctl));
                        }
                    }
                    sv_lang::kinds::ExpressionKind::Call => {
                        // A call's `vpiName` is the subroutine's.
                        self.model
                            .set_name(id, &e.call_subroutine_name().unwrap_or_default());
                        let builtin = e
                            .system_subroutine()
                            .is_some_and(|m| !m.name().starts_with('$'))
                            || (e.call_this_class().is_some() && receiver_listed(&e));
                        let operands = e.operands();
                        // A method's object (37.42 detail 2): a built-in's is
                        // slang's first argument.
                        if let Some(t) = e.call_this_class() {
                            expr(self, header("vpiPrefix"), Some(t));
                        } else if builtin {
                            expr(self, header("vpiPrefix"), operands.first().copied());
                        }
                        for a in operands.iter().skip(usize::from(builtin)) {
                            expr(self, consts::VPI_ARGUMENT, Some(*a));
                        }
                        if let Some(w) = self.call_with(&e) {
                            self.rel(id, header("vpiWith"), w);
                        }
                        // The task or function called (NULL for a built-in).
                        if let Some(sub) = e.call_subroutine() {
                            let rel =
                                if sub.subroutine_kind() == Some(sv_lang::SubroutineKind::Task) {
                                    "vpiTask"
                                } else {
                                    "vpiFunction"
                                };
                            self.tf_rel_links.push((id, header(rel), sub.uid()));
                        }
                    }
                    // `i++`/`--i`: an assignment with its operation (37.64).
                    _ => {
                        let op = op_type_of(&e).unwrap_or(0);
                        if let Some(p) = self.model.props_mut(id) {
                            p.blocking = true;
                            p.op_type = op;
                        }
                        expr(self, consts::VPI_LHS, e.operands().first().copied());
                    }
                }
            }
            S::Conditional => {
                expr(
                    self,
                    consts::VPI_CONDITION,
                    st.conditions().first().map(|c| c.expr()),
                );
                sub(self, consts::VPI_STMT, st.then_branch());
                sub(self, consts::VPI_ELSE_STMT, st.else_branch());
            }
            // `case ... matches` (12.6.1, 37.72): each item's pattern is its
            // `vpiExpr`, followed by its `&&&` filter when it has one.
            S::PatternCase => {
                let ct = match st.pattern_case_condition() {
                    Some(sv_lang::CaseStatementCondition::WildcardXOrZ) => c("vpiCaseX"),
                    Some(sv_lang::CaseStatementCondition::WildcardJustZ) => c("vpiCaseZ"),
                    _ => c("vpiCaseExact"),
                };
                if let Some(p) = self.model.props_mut(id) {
                    p.case_type = ct;
                }
                expr(
                    self,
                    consts::VPI_CONDITION,
                    vj_sim::patterns::pattern_case_expr(*st),
                );
                let items: Vec<_> = st
                    .pattern_case_items()
                    .into_iter()
                    .map(|i| (Some((i.pattern(), i.filter())), Some(i.stmt())))
                    .chain(st.pattern_case_default().map(|d| (None, Some(d))))
                    .collect();
                for (pat, body) in items {
                    let mut it = Obj::new(ObjKind::CaseItem, Some(id), "", "");
                    it.props.file = Some(self.file.clone());
                    it.props.line = body.map_or(0, |b| self.locator.stmt_line(&b));
                    let item = self.add(it);
                    if let Some((p, filter)) = pat {
                        if let Some(op) = self.pattern(&p, item) {
                            self.rel(item, consts::VPI_EXPR, op);
                        }
                        if let Some(f) = filter
                            && let Some(op) = self.operand(&f)
                        {
                            self.rel(item, consts::VPI_EXPR, op);
                        }
                    }
                    if let Some(b) = body
                        && let Some(o) = self.stmt(&b, item, &inner)
                    {
                        self.rel(item, consts::VPI_STMT, Operand::Obj(o));
                    }
                }
            }
            S::Case => {
                let ct = match st.case_condition() {
                    Some(sv_lang::CaseStatementCondition::WildcardXOrZ) => c("vpiCaseX"),
                    Some(sv_lang::CaseStatementCondition::WildcardJustZ) => c("vpiCaseZ"),
                    _ => c("vpiCaseExact"),
                };
                if let Some(p) = self.model.props_mut(id) {
                    p.case_type = ct;
                }
                expr(self, consts::VPI_CONDITION, st.expr());
                let items: Vec<(Vec<sv_lang::Expression<'_>>, Option<sv_lang::Statement<'_>>)> = st
                    .case_items()
                    .into_iter()
                    .map(|i| (i.expressions(), Some(i.stmt())))
                    .chain(st.default_case().map(|d| (Vec::new(), Some(d))))
                    .collect();
                for (exprs, body) in items {
                    let mut it = Obj::new(ObjKind::CaseItem, Some(id), "", "");
                    it.props.file = Some(self.file.clone());
                    it.props.line = body.map_or(0, |b| self.locator.stmt_line(&b));
                    let item = self.add(it);
                    for e in exprs {
                        if let Some(op) = self.operand(&e) {
                            self.rel(item, consts::VPI_EXPR, op);
                        }
                    }
                    if let Some(b) = body
                        && let Some(o) = self.stmt(&b, item, &inner)
                    {
                        self.rel(item, consts::VPI_STMT, Operand::Obj(o));
                    }
                }
            }
            S::ForLoop => {
                // `for (int a = 0, b = 5; ...)` (37.74): the loop variables
                // are the `for`'s own `vpiLocalVarDecls`, and each initializer
                // is an assignment to its variable.
                let mut loop_vars = Vec::new();
                for v in st.for_loop_vars() {
                    let at = self.model.len() as ObjId;
                    self.local_var(&v, id, &inner);
                    if self.model.len() as ObjId > at {
                        loop_vars.push((v, at));
                    }
                }
                for (v, vid) in loop_vars {
                    if let Some(init) = v.initializer()
                        && let Some(s) = self.var_init_stmt(vid, &init, id)
                    {
                        self.rel(id, consts::VPI_FOR_INIT_STMT, Operand::Obj(s));
                    }
                }
                for e in st.for_loop_initializers() {
                    match self.for_clause_stmt(&e, id) {
                        Some(s) => self.rel(id, consts::VPI_FOR_INIT_STMT, Operand::Obj(s)),
                        None => expr(self, consts::VPI_FOR_INIT_STMT, Some(e)),
                    }
                }
                expr(self, consts::VPI_CONDITION, st.condition());
                for e in st.for_loop_steps() {
                    match self.for_clause_stmt(&e, id) {
                        Some(s) => self.rel(id, consts::VPI_FOR_INC_STMT, Operand::Obj(s)),
                        None => expr(self, consts::VPI_FOR_INC_STMT, Some(e)),
                    }
                }
                sub(self, consts::VPI_STMT, st.body());
            }
            S::RepeatLoop | S::WhileLoop | S::DoWhileLoop => {
                expr(self, consts::VPI_CONDITION, st.condition().or(st.expr()));
                sub(self, consts::VPI_STMT, st.body());
            }
            S::ForeverLoop => sub(self, consts::VPI_STMT, st.body()),
            // 37.75: the array indexed, its index variables left to right
            // (a skipped one a `vpiNullOp` operation), and the body, which
            // refers to those variables.
            S::ForeachLoop => {
                expr(
                    self,
                    header("vpiVariables"),
                    st.expressions().first().copied(),
                );
                let mut vars = Vec::new();
                for d in st.foreach_loop_dims() {
                    let Some(sym) = d.loop_var() else {
                        let n = self.model.add_expr(ExprNode::Op {
                            op_type: header("vpiNullOp"),
                            width: 0,
                            operands: Vec::new(),
                            meta: OpMeta::default(),
                        });
                        vars.push(Operand::Expr(n));
                        continue;
                    };
                    let n = sym.name().to_owned();
                    let mut v = Obj::new(ObjKind::IntVar, Some(id), &n, &format!("{scope}.{n}"));
                    v.props.width = 32;
                    v.props.signed = true;
                    v.props.automatic = true;
                    v.props.file = Some(self.file.clone());
                    v.props.line = obj_line;
                    let vid = self.add(v);
                    vars.push(Operand::Obj(vid));
                }
                let mark = self.loop_vars.len();
                for v in &vars {
                    if let Operand::Obj(vid) = v
                        && let Some(o) = self.model.get(*vid)
                    {
                        self.loop_vars.push((o.name.clone(), *vid));
                    }
                }
                for v in vars {
                    self.rel(id, header("vpiLoopVars"), v);
                }
                sub(self, consts::VPI_STMT, st.body());
                self.loop_vars.truncate(mark);
            }
            S::Timed => {
                let tc = st.timing_control();
                let e = tc.and_then(|t| t.children().into_iter().find_map(|n| n.as_expression()));
                let rel = if ty == c("vpiDelayControl") {
                    consts::VPI_DELAY
                } else {
                    consts::VPI_CONDITION
                };
                // `@(posedge e)`/`@(negedge e)`: a vpiPosedgeOp/vpiNegedgeOp
                // operation over the signal (37.65).
                let edge = tc
                    .filter(|t| t.kind() == T::SignalEvent)
                    .and_then(|t| match t.edge() {
                        sv_lang::EdgeKind::PosEdge => Some(c("vpiPosedgeOp")),
                        sv_lang::EdgeKind::NegEdge => Some(c("vpiNegedgeOp")),
                        _ => None,
                    });
                match (edge, e) {
                    (Some(op_type), Some(sig)) => {
                        if let Some(operand) = self.operand(&sig) {
                            let width = 1;
                            let node = self.model.add_expr(ExprNode::Op {
                                op_type,
                                width,
                                operands: vec![operand],
                                meta: OpMeta::default(),
                            });
                            self.rel(id, rel, Operand::Expr(node));
                        }
                    }
                    _ => expr(self, rel, e),
                }
                sub(self, consts::VPI_STMT, st.body());
            }
            S::Return => expr(self, consts::VPI_CONDITION, st.expr()),
            S::Wait => {
                expr(self, consts::VPI_CONDITION, st.condition().or(st.expr()));
                sub(self, consts::VPI_STMT, st.body());
            }
            // 37.77: the block, task or function disabled, found once every
            // object exists (`disable_links`); the label is read from the
            // source like the lowering does.
            S::Disable => {
                let label = vj_sim::process::cfg::source_text_range(st.source_range())
                    .and_then(|t| {
                        t.trim()
                            .strip_prefix("disable")
                            .map(|r| r.trim().trim_end_matches(';').trim().to_owned())
                    })
                    .filter(|l| !l.is_empty());
                if let Some(l) = label {
                    self.disable_links.push((id, scope.to_owned(), l));
                }
            }
            // 37.62: the named event triggered.
            S::EventTrigger => {
                let target = st.expr().or_else(|| {
                    st.as_sem_node()
                        .children()
                        .into_iter()
                        .find_map(|n| n.as_expression())
                });
                if let Some(op) = target.and_then(|t| self.operand(&t)) {
                    self.rel(id, consts::VPI_EXPR, op);
                    self.rel(id, header("vpiNamedEvent"), op);
                }
            }
            S::ProceduralAssign => {
                let e = st.expr().or_else(|| {
                    st.as_sem_node()
                        .children()
                        .into_iter()
                        .find_map(|n| n.as_expression())
                });
                if let Some(a) = e {
                    expr(self, consts::VPI_LHS, a.left());
                    self.let_hint = Some(self.let_sites_of_expr(&a));
                    expr(self, consts::VPI_RHS, a.right());
                    self.let_hint = None;
                }
            }
            S::ProceduralDeassign => {
                let target = st.expr().or_else(|| {
                    st.as_sem_node()
                        .children()
                        .into_iter()
                        .find_map(|n| n.as_expression())
                });
                expr(self, consts::VPI_LHS, target);
            }
            _ => {}
        }
        Some(id)
    }

    /// A `let` declaration (37.57) with its formals as `vpiSeqFormalDecl`
    /// children.
    fn let_decl(&mut self, sym: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        let name = sym.name().to_owned();
        let full = format!("{parent_name}.{name}");
        let mut obj = Obj::new(ObjKind::LetDecl, Some(parent), &name, &full);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(sym);
        let id = self.add(obj);
        self.attributes(sym.attributes(), id, &full, false);
        self.formal_names.clear();
        for port in sym.let_decl_ports() {
            let pname = port.name().to_owned();
            let mut f = Obj::new(
                ObjKind::SeqFormalDecl,
                Some(id),
                &pname,
                &format!("{full}.{pname}"),
            );
            f.props.file = Some(self.file.clone());
            f.props.line = self.locator.line(&port);
            f.props.direction = match port.assertion_port_direction() {
                Some(ArgumentDirection::Out) => consts::VPI_OUTPUT,
                Some(ArgumentDirection::InOut) => consts::VPI_INOUT,
                _ => consts::VPI_INPUT,
            };
            let fid = self.add(f);
            self.formal_by_uid.insert(port.uid(), fid);
            self.formal_names.push((pname, fid));
            self.formal_default(&port, fid, None, &sym.parent().unwrap_or(*sym));
        }
        // The declaration's expression (37.57): the body slang bound in the
        // declaration's own scope (`bound_body`, formals as placeholders).
        let bound = sym.bound_body().map(unwrap_invalid_expr);
        let bound = bound.and_then(|b| self.let_body_concat(sym, &b).or_else(|| self.operand(&b)));
        self.formal_names.clear();
        if let Some(op) = bound {
            self.rel(id, consts::VPI_EXPR, op);
        }
        // No bound body: an opaque node carrying the source text.
        use sv_lang::AstNode;
        let mut body = None;
        for (ti, tree) in self.locator.syntax_trees().iter().enumerate() {
            if let Some(n) = sym
                .syntax(tree)
                .and_then(sv_lang::nodes::LetDeclarationSyntax::cast)
            {
                body = Some(n.expr().syntax().text().trim().to_owned());
                self.let_decls
                    .insert((ti, n.syntax().byte_range().start), id);
                break;
            }
        }
        if bound.is_none()
            && let Some(body) = body
        {
            let e = self.model.add_expr(ExprNode::Unsupported(format!(
                "the body `{body}` of a let declaration (slang binds it only at an instance)"
            )));
            self.rel(id, consts::VPI_EXPR, Operand::Expr(e));
        }
    }

    /// `body` (a right-hand side slang bound by expanding a `let`
    /// instance) as the `vpiLetExpr` the use site wrote (37.57), or `body`
    /// itself when `rhs_text` is no let instance. slang leaves no trace of
    /// the instance in the expansion, so it is recovered from the use
    /// site's text: `name` or `name(actuals)` naming a let visible from
    /// `scope`. An actual that is a literal becomes a `vpiConstant`, a plain
    /// signal name that signal, anything else a loud
    /// [`ExprNode::Unsupported`]; an omitted actual is the formal's default
    /// (detail 1).
    #[allow(clippy::too_many_arguments)]
    fn let_instance(
        &mut self,
        rhs_text: &str,
        expanded_text: Option<&str>,
        scope: ObjId,
        body: Operand,
        width: i32,
        known: Option<ObjId>,
        uses: &[(String, sv_lang::Expression<'_>)],
    ) -> Operand {
        let rhs = rhs_text.trim();
        // An expansion carries the declaration's text, not the use site's.
        if expanded_text.is_some_and(|t| t.trim() == rhs) {
            return body;
        }
        let ident_end = rhs
            .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_' || c == '$'))
            .unwrap_or(rhs.len());
        let (name, rest) = rhs.split_at(ident_end);
        if name.is_empty() || name.starts_with(|c: char| c.is_ascii_digit()) {
            return body;
        }
        let rest = rest.trim();
        let actuals: Vec<String> = if rest.is_empty() {
            Vec::new()
        } else if let Some(inner) = rest.strip_prefix('(').and_then(|r| r.strip_suffix(')')) {
            split_top_level(inner)
        } else {
            return body;
        };
        let mut decl = known;
        let mut at = known.is_none().then_some(scope);
        while let Some(sc) = at {
            let Some(o) = self.model.get(sc) else { break };
            if let Some(d) = self.model.find(&format!("{}.{name}", o.full_name))
                && self
                    .model
                    .get(d)
                    .is_some_and(|o| o.kind == ObjKind::LetDecl)
            {
                decl = Some(d);
                break;
            }
            at = o.parent;
        }
        let Some(decl) = decl else { return body };
        let formals = self.model.children_of_kind(decl, ObjKind::SeqFormalDecl);
        let mut given: Vec<Option<String>> = vec![None; formals.len()];
        for (i, a) in actuals.iter().enumerate() {
            let a = a.trim();
            if let Some(named) = a.strip_prefix('.') {
                let (fname, val) = named.split_once('(').unwrap_or((named, ""));
                let val = val.trim_end().trim_end_matches(')').trim();
                if let Some(k) = formals
                    .iter()
                    .position(|&f| self.model.get(f).is_some_and(|o| o.name == fname.trim()))
                {
                    given[k] = Some(val.to_owned());
                }
            } else if i < given.len() && !a.is_empty() {
                given[i] = Some(a.to_owned());
            }
        }
        let mut args = Vec::new();
        for (k, &f) in formals.iter().enumerate() {
            let op = match &given[k] {
                Some(text) if !text.is_empty() => {
                    let fname = self
                        .model
                        .get(f)
                        .map(|o| o.name.clone())
                        .unwrap_or_default();
                    Some(self.let_actual(text, scope, &fname, uses))
                }
                _ => self
                    .model
                    .get(f)
                    .and_then(|o| o.props.rels.iter().find(|(r, _)| *r == consts::VPI_EXPR))
                    .map(|(_, t)| *t),
            };
            args.push(op.unwrap_or_else(|| {
                Operand::Expr(self.model.add_expr(ExprNode::Unsupported(format!(
                    "the omitted argument {k} of let instance {name} (it has no default)"
                ))))
            }));
        }
        Operand::Expr(self.model.add_expr(ExprNode::LetInst {
            decl,
            name: name.to_owned(),
            args,
            body,
            width,
        }))
    }

    /// One actual of a let instance (see [`Self::let_instance`]).
    ///
    /// A plain name is its object; any other actual is the expression slang
    /// substituted for the formal `fname` in the expansion (`uses`), a real
    /// expression object; the rest falls back to the literal / loud-text
    /// node.
    fn let_actual(
        &mut self,
        text: &str,
        scope: ObjId,
        fname: &str,
        uses: &[(String, sv_lang::Expression<'_>)],
    ) -> Operand {
        if !text.is_empty() && text.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
            let mut at = Some(scope);
            while let Some(sc) = at {
                let Some(o) = self.model.get(sc) else { break };
                if let Some(t) = self.model.find(&format!("{}.{text}", o.full_name)) {
                    return Operand::Obj(t);
                }
                at = o.parent;
            }
        }
        if let Some((_, x)) = uses.iter().find(|(f, _)| f == fname)
            && let Some(op) = self.operand(x)
        {
            return op;
        }
        Operand::Expr(self.model.add_expr(formal_default_node(text)))
    }

    /// The `let` declaration whose body contains `x`'s syntax, if any.
    fn let_decl_of(&self, trees: &[SyntaxTree], x: &sv_lang::Expression<'_>) -> Option<ObjId> {
        use sv_lang::AstNode;
        for (ti, tree) in trees.iter().enumerate() {
            let Some(mut n) = x.syntax(tree) else {
                continue;
            };
            loop {
                if let Some(d) = sv_lang::nodes::LetDeclarationSyntax::cast(n) {
                    return self
                        .let_decls
                        .get(&(ti, d.syntax().byte_range().start))
                        .copied();
                }
                n = n.parent()?;
            }
        }
        None
    }

    /// Every invocation of a `let` under `node` (and `node` itself), in
    /// source order.
    fn collect_let_sites(&self, node: sv_lang::Node<'_>) -> Vec<LetSite> {
        use sv_lang::AstNode;
        let names: Vec<&str> = self
            .let_decls
            .values()
            .filter_map(|&d| self.model.get(d).map(|o| o.name.as_str()))
            .collect();
        let mut out = Vec::new();
        for n in node.descendants() {
            if let Some(inv) = sv_lang::nodes::InvocationExpressionSyntax::cast(n) {
                let l = inv.left().syntax().text();
                let callee = l.trim().rsplit(['.', ':']).next().unwrap_or("");
                if names.contains(&callee) {
                    out.push(LetSite {
                        name: callee.to_owned(),
                        text: n.text(),
                    });
                }
            } else if let Some(id) = sv_lang::nodes::IdentifierNameSyntax::cast(n)
                && let Some(callee) = Some(n.text().trim().to_owned())
                && names.contains(&callee.as_str())
                && !n.parent().is_some_and(|p| {
                    // The callee of an invocation is covered above; a
                    // let declaration's own name is no use.
                    sv_lang::nodes::InvocationExpressionSyntax::cast(p)
                        .is_some_and(|i| i.left().syntax().byte_range() == id.syntax().byte_range())
                })
                && !Self::name_shadowed(n, &callee)
            {
                // A let instance with no parenthesised actuals (`c`, 37.57).
                out.push(LetSite {
                    name: callee.clone(),
                    text: callee,
                });
            }
        }
        out
    }

    /// Whether the identifier `id` (naming `name`) lies in the scope of a
    /// data declaration of the same name made in a block or loop that
    /// encloses it (LRM 23.9 / 3.13: the innermost declaration hides the
    /// let, so the identifier is no let instance). A declarator belongs to
    /// the nearest enclosing sequential block, `for`/`foreach` loop or
    /// subroutine; a subroutine's formals are declarators of the subroutine
    /// scope (LRM 13.3, 13.4), so a formal hides a same-named let too.
    fn name_shadowed(id: sv_lang::Node<'_>, name: &str) -> bool {
        use sv_lang::AstNode;
        use sv_lang::nodes::{
            BlockStatementSyntax, DeclaratorSyntax, ForLoopStatementSyntax,
            ForeachLoopStatementSyntax, FunctionDeclarationSyntax,
        };
        let is_scope = |n: sv_lang::Node<'_>| {
            BlockStatementSyntax::cast(n).is_some()
                || ForLoopStatementSyntax::cast(n).is_some()
                || ForeachLoopStatementSyntax::cast(n).is_some()
                || FunctionDeclarationSyntax::cast(n).is_some()
        };
        let mut at = id.parent();
        while let Some(a) = at {
            if is_scope(a) {
                for d in a.descendants() {
                    let Some(decl) = DeclaratorSyntax::cast(d) else {
                        continue;
                    };
                    if !decl.name().is_some_and(|t| t.text() == name) {
                        continue;
                    }
                    let mut up = d.parent();
                    while let Some(u) = up {
                        if is_scope(u) {
                            break;
                        }
                        up = u.parent();
                    }
                    if up.is_some_and(|u| u.byte_range() == a.byte_range()) {
                        return true;
                    }
                }
            }
            at = a.parent();
        }
        false
    }

    /// The `let` invocations written in `x`'s syntax.
    fn let_sites_of_expr(&self, x: &sv_lang::Expression<'_>) -> Vec<LetSite> {
        if self.let_decls.is_empty() {
            return Vec::new();
        }
        let trees = self.locator.syntax_trees();
        match trees.iter().find_map(|t| x.syntax(t)) {
            Some(n) => self.collect_let_sites(n),
            None => Vec::new(),
        }
    }

    /// The `let` invocations written in `sym`'s syntax.
    fn let_sites_of_symbol(&self, sym: &Symbol<'_>) -> Vec<LetSite> {
        if self.let_decls.is_empty() {
            return Vec::new();
        }
        let trees = self.locator.syntax_trees();
        match trees.iter().find_map(|t| sym.syntax(t)) {
            Some(n) => self.collect_let_sites(n),
            None => Vec::new(),
        }
    }

    /// `e` as the `vpiLetExpr` of the `let` instance it expands (37.57),
    /// wherever the instance occurs. slang leaves no trace of the instance:
    /// an expansion's syntax lies in the declaration, its actuals are
    /// substituted for the formals (a formal's use in the body is the
    /// actual's expression), and no use-site range survives. The instance
    /// is therefore matched to the next not yet consumed invocation of the
    /// declaration's name in the enclosing expression's source
    /// (`self.let_sites`, in the order slang binds and this builder visits
    /// them), and refused (the expansion stays as is) when a plain-name
    /// actual of that invocation is not what slang substituted. An instance
    /// with no parenthesised actuals is an identifier naming the let, found
    /// by [`Self::collect_let_sites`] the same way, except where a same-named
    /// variable of an enclosing block or loop hides the let
    /// ([`Self::name_shadowed`]).
    fn let_root(&mut self, e: &sv_lang::Expression<'_>) -> Option<Operand> {
        if self.let_sites.is_empty() || self.let_depth > 0 {
            return None;
        }
        let trees = self.locator.syntax_trees();
        let decl = self.let_decl_of(&trees, e)?;
        let name = self.model.get(decl)?.name.clone();
        let idx = self.let_sites.iter().position(|s| s.name == name)?;
        let formals: Vec<String> = self
            .model
            .children_of_kind(decl, ObjKind::SeqFormalDecl)
            .iter()
            .filter_map(|&f| self.model.get(f).map(|o| o.name.clone()))
            .collect();
        // The expression substituted for each formal: the one whose syntax
        // is that formal's identifier in the body.
        let mut uses: Vec<(String, sv_lang::Expression<'_>)> = Vec::new();
        let mut stack = vec![e.as_sem_node()];
        while let Some(n) = stack.pop() {
            if let Some(x) = n.as_expression()
                && let Some(node) = trees.iter().find_map(|t| x.syntax(t))
                && self.let_decl_of(&trees, &x) == Some(decl)
            {
                let t = node.text();
                let t = t.trim();
                if formals.iter().any(|f| f == t) && !uses.iter().any(|(f, _)| f == t) {
                    uses.push((t.to_owned(), x));
                }
            }
            stack.extend(n.children());
        }
        // A plain-name actual must be the symbol slang substituted.
        let text = self.let_sites[idx].text.clone();
        let inner = text
            .find('(')
            .map(|i| text[i + 1..].trim_end().trim_end_matches(')').to_owned())
            .unwrap_or_default();
        for (i, a) in split_top_level(&inner).iter().enumerate() {
            let a = a.trim();
            let (fname, val) = match a.strip_prefix('.') {
                Some(named) => {
                    let (f, v) = named.split_once('(').unwrap_or((named, ""));
                    (
                        Some(f.trim().to_owned()),
                        v.trim_end().trim_end_matches(')').trim(),
                    )
                }
                None => (formals.get(i).cloned(), a),
            };
            let plain =
                !val.is_empty() && val.chars().all(|c| c.is_ascii_alphanumeric() || c == '_');
            if plain
                && let Some(f) = fname
                && let Some((_, x)) = uses.iter().find(|(u, _)| *u == f)
                && x.kind() == sv_lang::kinds::ExpressionKind::NamedValue
                && x.referenced_symbol().is_some_and(|s| s.name() != val)
            {
                return None;
            }
        }
        self.let_sites.remove(idx);
        let width = e.expr_type().map_or(0, |t| t.bit_width() as i32);
        self.let_depth += 1;
        let body = self.operand_inner(e);
        self.let_depth -= 1;
        let scope = self.model.get(decl).and_then(|o| o.parent).unwrap_or(decl);
        Some(self.let_instance(&text, None, scope, body?, width, Some(decl), &uses))
    }

    /// A formal argument's default value (37.51 detail 6, 37.53, 37.57): the
    /// `vpiExpr` of the formal. Slang binds a default only where it is
    /// instantiated, so it is read from the declaration's syntax: a literal
    /// becomes a `vpiConstant`, any other expression a loud
    /// [`ExprNode::Unsupported`] naming its source text.
    fn formal_default(
        &mut self,
        port: &Symbol<'_>,
        fid: ObjId,
        bound: Option<Operand>,
        scope: &Symbol<'_>,
    ) {
        use sv_lang::AstNode;
        use sv_lang::nodes::AssertionItemPortSyntax;
        let mut text = None;
        let mut bound_here = None;
        for tree in self.locator.syntax_trees() {
            if let Some(n) = port
                .syntax(&tree)
                .and_then(AssertionItemPortSyntax::cast)
                .and_then(|n| n.default_value())
            {
                text = Some(n.expr().syntax().text().trim().to_owned());
                // Bound in the declaration's enclosing scope, as slang does
                // at an instance that omits the actual (16.8.1, 37.51).
                if bound.is_none()
                    && let Some(syn) = port.assertion_port_default_syntax(&tree)
                    // A default is a property/sequence expression in the
                    // syntax: a plain expression is the one inside it.
                    && let Some(e) = self.eval.bind_expression(
                        sv_lang::nodes::SimpleSequenceExprSyntax::cast(syn)
                            .or_else(|| syn.find_first::<sv_lang::nodes::SimpleSequenceExprSyntax>())
                            .map_or(syn, |q| q.expr().syntax()),
                        *scope,
                    )
                {
                    let e = unwrap_invalid_expr(e);
                    if !e.is_bad() {
                        bound_here = self.operand(&e);
                    }
                }
                break;
            }
        }
        let bound = bound.or(bound_here);
        let Some(text) = text else { return };
        let node = formal_default_node(&text);
        // A non-literal default is the actual slang bound for it in the
        // declaration's own scope (`bound_body`'s instance arguments).
        if matches!(node, ExprNode::Unsupported(_))
            && let Some(op) = bound
        {
            self.rel(fid, consts::VPI_EXPR, op);
            return;
        }
        let e = self.model.add_expr(node);
        self.rel(fid, consts::VPI_EXPR, Operand::Expr(e));
    }

    /// The parameters `e` names, at any depth (37.58: a use in a folded
    /// constant select).
    fn named_parameters(e: &sv_lang::Expression<'_>, out: &mut Vec<SymbolId>) {
        use sv_lang::kinds::ExpressionKind as K;
        if e.kind() == K::NamedValue
            && let Some(sym) = e.referenced_symbol()
            && matches!(sym.kind(), SymbolKind::Parameter | SymbolKind::Specparam)
        {
            out.push(sym.uid());
        }
        for o in e.operands() {
            Self::named_parameters(&o, out);
        }
        if let Some(inner) = e.conversion_operand() {
            Self::named_parameters(&inner, out);
        }
    }

    /// The expression a declaration range or dimension holds around an
    /// identifier `n` below it (`[P-1:0]` gives `P-1`, `[Q]` gives `Q`): the
    /// highest ancestor of `n` whose parent is the select or dimension
    /// itself. `None` when that is not a plain expression (a queue bound
    /// `[$:P]`, a type dimension).
    fn range_expr_root<'t>(n: sv_lang::Node<'t>) -> Option<sv_lang::Node<'t>> {
        use sv_lang::kinds::SyntaxKind as SK;
        let mut cur = n;
        loop {
            let p = cur.parent()?;
            if matches!(
                p.kind(),
                SK::SimpleRangeSelect
                    | SK::BitSelect
                    | SK::AscendingRangeSelect
                    | SK::DescendingRangeSelect
                    | SK::RangeDimensionSpecifier
                    | SK::VariableDimension
                    | SK::ColonExpressionClause
            ) {
                let k = format!("{:?}", cur.kind());
                return (matches!(k.as_str(), "IdentifierName" | "ScopedName")
                    || k.ends_with("Expression"))
                .then_some(cur);
            }
            cur = p;
        }
    }

    /// 37.58: binds the declaration range expression `root` (syntax tree
    /// `tree_ix`) in the scope of the parameter `sym` and records it as a
    /// `vpiUse` of every parameter it names, once per (scope, expression).
    /// A bare name (`[Q:0]`) is a no-operator operation holding the
    /// parameter. `false` when the expression cannot be bound: the use then
    /// stays refused by name.
    fn range_use_expr(
        &mut self,
        sym: &Symbol<'_>,
        tree_ix: usize,
        root: sv_lang::Node<'_>,
    ) -> bool {
        let Some(scope) = sym.parent() else {
            return false;
        };
        self.bind_range_expr(&scope, tree_ix, root, Some(sym.uid()))
    }

    /// `range_use_expr` for the expression `root` in `scope`; with `only`,
    /// the expression is kept only when it names that parameter.
    fn bind_range_expr(
        &mut self,
        scope: &Symbol<'_>,
        tree_ix: usize,
        root: sv_lang::Node<'_>,
        only: Option<SymbolId>,
    ) -> bool {
        let r = root.byte_range();
        let key = (scope.uid(), tree_ix, r.start, r.end);
        if self.range_exprs.contains(&key) {
            return true;
        }
        let Some(e) = self.eval.bind_expression(root, *scope) else {
            return false;
        };
        let e = unwrap_invalid_expr(e);
        if e.is_bad() {
            return false;
        }
        let mut named = Vec::new();
        Self::named_parameters(&e, &mut named);
        if only.is_some_and(|u| !named.contains(&u)) {
            // Not this parameter (a shadowing name): no use here.
            return true;
        }
        let Some(Operand::Expr(x)) = self.operand(&e) else {
            return false;
        };
        self.range_exprs.insert(key);
        for p in named {
            self.param_links.push((x, p));
        }
        true
    }

    /// The loop genvars a definition declares (`for (genvar i = ...)`): names
    /// a generate expression cannot be bound with in the parameter's scope.
    fn genvar_names(def: sv_lang::Node<'_>) -> Vec<String> {
        use sv_lang::kinds::SyntaxKind as SK;
        let mut out = Vec::new();
        def.visit(|n| {
            if n.kind() == SK::LoopGenerate {
                let t = n.text();
                let t = t.split_once('(').map_or("", |x| x.1).trim_start();
                let t = t.strip_prefix("genvar").map_or(t, str::trim_start);
                let id: String = t
                    .chars()
                    .take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '$')
                    .collect();
                if !id.is_empty() {
                    out.push(id);
                }
            }
            sv_lang::Walk::Continue
        });
        out
    }

    /// Where the identifier whose ancestors are `chain` (innermost first;
    /// the last entry is the child of the generate construct `a` it sits
    /// below) stands in `a`: in the condition, bound or item expression
    /// (with the expression nodes on the way up), or in the body.
    fn gen_position<'t>(a: &sv_lang::Node<'t>, chain: &[sv_lang::Node<'t>]) -> GenPos<'t> {
        use sv_lang::kinds::SyntaxKind as SK;
        let Some(last) = chain.last() else {
            return GenPos::Unknown;
        };
        let kids: Vec<_> = a.children().collect();
        let (Some(first), Some(end)) = (kids.first(), kids.last()) else {
            return GenPos::Unknown;
        };
        let is_last = last.byte_range() == end.byte_range();
        let is_first = last.byte_range() == first.byte_range();
        let cond = match a.kind() {
            SK::IfGenerate | SK::CaseGenerate => is_first,
            SK::LoopGenerate | SK::StandardCaseItem => !is_last,
            _ => return GenPos::Unknown,
        };
        if !cond {
            return GenPos::Body;
        }
        let exprs: Vec<_> = chain
            .iter()
            .copied()
            .filter(|c| {
                let k = format!("{:?}", c.kind());
                matches!(k.as_str(), "IdentifierName" | "ScopedName") || k.ends_with("Expression")
            })
            .collect();
        if exprs.is_empty() {
            GenPos::Unknown
        } else {
            GenPos::Cond(exprs)
        }
    }

    /// 37.58: the use of the parameter `sym` in a generate condition, bound
    /// or case expression whose candidate expressions are `cands` (innermost
    /// first). The largest one that binds in the parameter's scope and names
    /// no loop genvar is the use. `false` when none does.
    fn gen_use_expr(
        &mut self,
        sym: &Symbol<'_>,
        tree_ix: usize,
        cands: &[sv_lang::Node<'_>],
        genvars: &[String],
    ) -> bool {
        let Some(scope) = sym.parent() else {
            return false;
        };
        self.bind_use_expr_in(&scope, tree_ix, cands, genvars, Some(sym.uid()))
    }

    /// `gen_use_expr` in the instance body `scope`, for any parameter.
    fn bind_use_expr(
        &mut self,
        scope: &Symbol<'_>,
        tree_ix: usize,
        cands: &[sv_lang::Node<'_>],
        genvars: &[String],
    ) -> bool {
        self.bind_use_expr_in(scope, tree_ix, cands, genvars, None)
    }

    fn bind_use_expr_in(
        &mut self,
        scope: &Symbol<'_>,
        tree_ix: usize,
        cands: &[sv_lang::Node<'_>],
        genvars: &[String],
        only: Option<SymbolId>,
    ) -> bool {
        use sv_lang::kinds::SyntaxKind as SK;
        for c in cands.iter().rev() {
            let mut hit = false;
            c.visit(|n| {
                if n.kind() == SK::IdentifierName && genvars.iter().any(|g| *g == n.text().trim()) {
                    hit = true;
                }
                sv_lang::Walk::Continue
            });
            if !hit && self.bind_range_expr(scope, tree_ix, *c, only.clone()) {
                return true;
            }
        }
        false
    }

    /// Where the identifier `n` is named, for 37.58: in a place the model
    /// binds an expression object for (`Modelled`: ordinary code, a
    /// parameter initialiser, an instance override), in a declaration range
    /// or dimension (`Range`, the range expression), in a generate
    /// condition, bound or item (`Gen`, the candidate expressions), or
    /// somewhere it keeps none (`Refused`).
    fn classify_use<'t>(n: sv_lang::Node<'t>) -> UseCtx<'t> {
        use sv_lang::kinds::SyntaxKind as SK;
        let mut cur = n.parent();
        let mut in_init = false;
        let mut chain = vec![n];
        let mut gen_cands = None;
        while let Some(a) = cur {
            if !matches!(
                a.kind(),
                SK::IfGenerate | SK::CaseGenerate | SK::LoopGenerate | SK::StandardCaseItem
            ) {
                chain.push(a);
            }
            match a.kind() {
                SK::EqualsValueClause => in_init = true,
                // A value parameter's initialiser is modelled
                // (parameter_default binds it: an operation, or for a bare
                // name the parameter object itself, whose holder is the
                // declaring parameter).
                SK::ParameterDeclaration if in_init => {}
                // An instance's `#(...)` override is modelled (param_assigns
                // binds it, or marks the parameter folded when it cannot).
                SK::ParameterValueAssignment
                    if a.parent()
                        .is_some_and(|p| p.kind() == SK::HierarchyInstantiation) => {}
                // A declaration range / dimension is modelled
                // (range_use_expr binds it); a shape it cannot bind stays
                // refused.
                // The leftmost packed range of a module-level variable or net
                // is bound once, as the object's vpiLeftRange/vpiRightRange
                // (range_exprs): the declared object is the use of a bare
                // bound (a variable or net is a simple expr, a valid
                // vpiUse target), an operation that of a compound one.
                SK::RangeDimensionSpecifier
                    if a.parent().is_some_and(|d| Self::modelled_decl_dim(&d)) =>
                {
                    return UseCtx::Modelled;
                }
                SK::VariableDimension if Self::modelled_decl_dim(&a) => return UseCtx::Modelled,
                SK::RangeDimensionSpecifier | SK::VariableDimension => {
                    return Self::range_expr_root(n).map_or(UseCtx::Refused, UseCtx::Range);
                }
                // A dimension after a type name (`t_t [P:0] x`) parses as a
                // select on the name.
                SK::ElementSelect
                    if a.parent()
                        .and_then(|p| p.parent())
                        .is_some_and(|t| t.kind() == SK::NamedType) =>
                {
                    return Self::range_expr_root(n).map_or(UseCtx::Refused, UseCtx::Range);
                }
                // A generate condition, loop bound or case selector/item is
                // modelled (gen_use_expr); a use in the body below it is
                // ordinary code, but an enclosing generate's condition can
                // still hold the name.
                SK::IfGenerate | SK::CaseGenerate | SK::LoopGenerate | SK::StandardCaseItem => {
                    let ch = std::mem::replace(&mut chain, vec![a]);
                    match Self::gen_position(&a, &ch) {
                        GenPos::Cond(c) => {
                            gen_cands = Some(c);
                            break;
                        }
                        GenPos::Body => {}
                        GenPos::Unknown => return UseCtx::Refused,
                    }
                    cur = a.parent();
                    continue;
                }
                // A class specialization's or interface port's `#(...)`
                // value: the expression below the assignment is bound in
                // the scope like a range.
                SK::ParameterValueAssignment => {
                    return Self::expr_candidates(&chain[..chain.len() - 1]);
                }
                // A path delay, timing-check limit or specparam initialiser
                // is modelled (spec_param, path delays and tchk bind the
                // expression, or mark its parameters folded through
                // fold_if_unmodelled): binding it again here would list the
                // use twice.
                SK::SpecifyBlock | SK::SpecparamDeclaration => return UseCtx::Modelled,
                SK::ParameterDeclaration => return UseCtx::Refused,
                _ => {}
            }
            cur = a.parent();
        }
        gen_cands.map_or(UseCtx::Modelled, UseCtx::Gen)
    }

    /// The expression nodes among `chain` (innermost first) as candidates
    /// for binding, or `Refused` when there is none.
    fn expr_candidates<'t>(chain: &[sv_lang::Node<'t>]) -> UseCtx<'t> {
        let c: Vec<_> = chain
            .iter()
            .copied()
            .filter(|c| {
                let k = format!("{:?}", c.kind());
                matches!(k.as_str(), "IdentifierName" | "ScopedName") || k.ends_with("Expression")
            })
            .collect();
        if c.is_empty() {
            UseCtx::Refused
        } else {
            UseCtx::Gen(c)
        }
    }

    /// The module, interface or program declaration around `n`.
    fn enclosing_instance_def<'t>(n: sv_lang::Node<'t>) -> Option<sv_lang::Node<'t>> {
        use sv_lang::kinds::SyntaxKind as SK;
        let mut cur = n.parent();
        while let Some(d) = cur {
            if matches!(
                d.kind(),
                SK::ModuleDeclaration | SK::InterfaceDeclaration | SK::ProgramDeclaration
            ) {
                return Some(d);
            }
            cur = d.parent();
        }
        None
    }

    /// 37.58: binds, in the instance body `body`, the declaration ranges,
    /// generate conditions and bounds of its definition that hold a
    /// qualified name (`pkg::P`, `u.P`, which the per-parameter scan of
    /// `param_has_folded_use` cannot see from the declaring side) and
    /// records each as a `vpiUse` of every parameter it names. A name that
    /// cannot be bound is remembered in `qual_fail`, so its parameters are
    /// refused by name.
    fn qualified_uses(&mut self, body: &Symbol<'_>) {
        use sv_lang::kinds::SyntaxKind as SK;
        let trees = self.locator.syntax_trees();
        for (tree_ix, tree) in trees.iter().enumerate() {
            let Some(decl) = body.syntax(tree) else {
                continue;
            };
            let Some(def) = std::iter::successors(Some(decl), |d| d.parent()).find(|d| {
                matches!(
                    d.kind(),
                    SK::ModuleDeclaration | SK::InterfaceDeclaration | SK::ProgramDeclaration
                )
            }) else {
                continue;
            };
            let genvars = Self::genvar_names(def);
            let mut found: Vec<(Vec<sv_lang::Node<'_>>, String)> = Vec::new();
            def.visit(|n| {
                if n.kind() == SK::IdentifierName
                    && n.parent().is_some_and(|p| p.kind() == SK::ScopedName)
                {
                    let last = n.text().trim().to_owned();
                    match Self::classify_use(n) {
                        UseCtx::Range(r) => found.push((vec![r], last)),
                        UseCtx::Gen(c) => found.push((c, last)),
                        UseCtx::Refused => {
                            self.qual_fail.insert(last);
                        }
                        UseCtx::Modelled => {}
                    }
                }
                sv_lang::Walk::Continue
            });
            for (cands, last) in found {
                if !self.bind_use_expr(body, tree_ix, &cands, &genvars) {
                    self.qual_fail.insert(last);
                }
            }
        }
        // Parameters built before a failure was known.
        let fails: Vec<_> = self.qual_fail.iter().cloned().collect();
        for (name, id) in self.param_objs.clone() {
            if fails.contains(&name) {
                self.model.mark_param_folded(id);
            }
        }
    }

    /// Whether the parameter `sym` is named where the model keeps no
    /// expression object: a declaration range, a generate condition or loop
    /// bound (folded to constants), or a qualified name (`u.P`, which may come from another
    /// module). Found on the syntax: any identifier `P` below such a node in
    /// the declaring definition, or in a qualified name anywhere. Over-
    /// approximate on purpose (a shadowing local counts), because the answer
    /// only decides whether `vpiUse` is refused by name rather than listed.
    /// Whether the `VariableDimension` node `d` is the leftmost packed
    /// dimension of a module-level variable or net declaration (`reg [Q:0] r;`,
    /// `wire [Q-1:0] w;`): the one range [`Self::range_exprs`] binds, so a
    /// parameter named there is not folded.
    fn modelled_decl_dim(d: &sv_lang::Node<'_>) -> bool {
        use sv_lang::kinds::SyntaxKind as SK;
        if d.kind() != SK::VariableDimension {
            return false;
        }
        let Some(ty) = d.parent() else { return false };
        if !matches!(
            ty.kind(),
            SK::LogicType | SK::RegType | SK::BitType | SK::ImplicitType
        ) {
            return false;
        }
        let first = ty.children().find(|c| c.kind() == SK::VariableDimension);
        if first.is_none_or(|f| f.byte_range().start != d.byte_range().start) {
            return false;
        }
        let Some(decl) = ty.parent() else {
            return false;
        };
        matches!(decl.kind(), SK::DataDeclaration | SK::NetDeclaration)
            && decl.parent().is_some_and(|m| {
                matches!(
                    m.kind(),
                    SK::ModuleDeclaration | SK::InterfaceDeclaration | SK::ProgramDeclaration
                )
            })
    }

    /// 37.58: binds the bounds of the leftmost declared packed range of a
    /// variable or net (`reg [Q-1:0] v`) when they name a parameter, as the
    /// `vpiLeftRange`/`vpiRightRange` expressions of `id`, so those names have
    /// a `vpiUse`. A bound that cannot be bound marks its parameters folded.
    fn range_exprs(&mut self, sym: &Symbol<'_>, id: ObjId) {
        use sv_lang::kinds::SyntaxKind as SK;
        let Some(scope) = sym.parent() else { return };
        for tree in self.locator.syntax_trees() {
            let Some(decl) = sym.syntax(&tree) else {
                continue;
            };
            let mut dim = None;
            let mut up = decl.parent();
            while let Some(a) = up {
                if matches!(a.kind(), SK::DataDeclaration | SK::NetDeclaration) {
                    a.visit(|n| {
                        if dim.is_none() && Self::modelled_decl_dim(&n) {
                            dim = Some(n);
                        }
                        sv_lang::Walk::Continue
                    });
                    break;
                }
                up = a.parent();
            }
            let Some(dim) = dim else { return };
            let mut range = None;
            dim.visit(|n| {
                if range.is_none() && n.kind() == SK::SimpleRangeSelect {
                    range = Some(n);
                }
                sv_lang::Walk::Continue
            });
            let Some(range) = range else { return };
            let (Some(l), Some(r)) = (range.children().next(), range.children().last()) else {
                return;
            };
            let mut ops = Vec::new();
            let mut any = false;
            let mut ok = true;
            for (n, key) in [(l, consts::VPI_LEFT_RANGE), (r, consts::VPI_RIGHT_RANGE)] {
                let e = self
                    .eval
                    .bind_expression(n, scope)
                    .map(unwrap_invalid_expr)
                    .filter(|e| !e.is_bad());
                let Some(e) = e else {
                    ok = false;
                    continue;
                };
                let mut named = Vec::new();
                Self::named_parameters(&e, &mut named);
                any |= !named.is_empty();
                let op = self.operand(&e);
                let good = op.is_some_and(|o| match o {
                    Operand::Expr(x) => {
                        !matches!(self.model.expr(x), Some(ExprNode::Unsupported(_)))
                    }
                    Operand::Obj(_) => true,
                });
                match op {
                    Some(o) if good => ops.push((key, o)),
                    _ => {
                        ok = false;
                        for p in named {
                            if let Some(pid) = self.prop_by_uid.get(&p).copied() {
                                self.model.mark_param_folded(pid);
                            }
                        }
                    }
                }
            }
            if !ok {
                // Fold every parameter the text names (a bound that failed
                // to bind may name some the other half did not).
                let mut idents = Vec::new();
                range.visit(|n| {
                    if n.kind() == SK::IdentifierName {
                        idents.push(n.text().trim().to_owned());
                    }
                    sv_lang::Walk::Continue
                });
                for name in idents {
                    if let Some(p) = scope.find(&name)
                        && let Some(pid) = self.prop_by_uid.get(&p.uid()).copied()
                    {
                        self.model.mark_param_folded(pid);
                    }
                }
                return;
            }
            // Only a range that names a parameter needs expression objects
            // (the others keep the constant bounds).
            if any {
                for (key, o) in ops {
                    self.rel(id, key, o);
                }
            }
            return;
        }
    }

    fn param_has_folded_use(&mut self, sym: &Symbol<'_>) -> bool {
        use sv_lang::kinds::SyntaxKind as SK;
        let name = sym.name().to_owned();
        let trees = self.locator.syntax_trees();
        let qualified = self.qualified_idents.get_or_insert_with(|| {
            // A qualified name written outside a module, interface or
            // program definition (a package, a class, $unit) in a place
            // the model keeps no expression for: refused by name. Inside a
            // definition `qualified_uses` binds it per instance.
            let mut set = std::collections::HashSet::new();
            for tree in &trees {
                tree.root().visit(|n| {
                    if n.kind() == SK::IdentifierName
                        && n.parent().is_some_and(|p| p.kind() == SK::ScopedName)
                        && !matches!(Self::classify_use(n), UseCtx::Modelled)
                        && Self::enclosing_instance_def(n).is_none()
                    {
                        set.insert(n.text().trim().to_owned());
                    }
                    sv_lang::Walk::Continue
                });
            }
            set
        });
        if qualified.contains(&name) || self.qual_fail.contains(&name) {
            return true;
        }
        for (tree_ix, tree) in trees.iter().enumerate() {
            let Some(decl) = sym.syntax(tree) else {
                continue;
            };
            let mut def = decl.parent();
            while let Some(d) = def {
                if matches!(
                    d.kind(),
                    SK::ModuleDeclaration
                        | SK::InterfaceDeclaration
                        | SK::ProgramDeclaration
                        | SK::PackageDeclaration
                ) {
                    break;
                }
                def = d.parent();
            }
            let Some(def) = def else {
                return true;
            };
            let mut folded = false;
            let mut ranges = Vec::new();
            let mut gens = Vec::new();
            let genvars = Self::genvar_names(def);
            def.visit(|n| {
                if n.kind() == SK::IdentifierName && n.text().trim() == name {
                    match Self::classify_use(n) {
                        UseCtx::Range(r) => ranges.push(r),
                        UseCtx::Gen(c) => gens.push(c),
                        UseCtx::Refused => folded = true,
                        UseCtx::Modelled => {}
                    }
                }
                sv_lang::Walk::Continue
            });
            for r in ranges {
                if !self.range_use_expr(sym, tree_ix, r) {
                    folded = true;
                }
            }
            for cands in gens {
                if !self.gen_use_expr(sym, tree_ix, &cands, &genvars) {
                    folded = true;
                }
            }
            return folded;
        }
        // No declaring syntax (a parameter slang synthesised): unknown.
        true
    }

    fn parameter(&mut self, sym: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        self.parameter_sep(sym, parent, parent_name, ".");
    }

    /// `parameter` with the separator between the scope name and the
    /// parameter (`::` for a package member).
    fn parameter_sep(&mut self, sym: &Symbol<'_>, parent: ObjId, parent_name: &str, sep: &str) {
        let name = sym.name().to_owned();
        let full = format!("{parent_name}{sep}{name}");
        let mut obj = Obj::new(ObjKind::Parameter, Some(parent), &name, &full);
        obj.props.local_param = sym.parameter_is_local_param();
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(sym);
        Self::fill_value(&mut obj.props, &sym.constant_value());
        // 37.28 detail 5: `vpiLeftRange`/`vpiRightRange` exist only for a
        // declared packed range (`parameter [7:0] S`), not for `int` or an
        // untyped parameter.
        if let Some(t) = sym.declared_type()
            && !t.is_alias()
            && self.locator.syntax_trees().iter().any(|tr| {
                sym.declared_type_syntax(tr)
                    .is_some_and(|n| n.text().contains('['))
            })
        {
            let canon = t.canonical();
            if canon.is_packed_array() {
                let r = canon.fixed_range();
                obj.props.range = Some((r.left, r.right));
            }
        }
        let id = self.add(obj);
        self.prop_by_uid.insert(sym.uid(), id);
        self.param_objs.push((name.clone(), id));
        if self.param_has_folded_use(sym) {
            self.model.mark_param_folded(id);
        }
        self.attributes(sym.attributes(), id, &full, false);
        self.typespec_rel(id, sym.declared_type());
        self.parameter_default(sym, id);
    }

    /// A value parameter's `vpiExpr` (37.28 detail 3): its default
    /// expression, read from the declaration's syntax (the symbol itself
    /// holds the applied override). A literal becomes a `vpiConstant`, any
    /// other expression is bound in the parameter's scope.
    fn parameter_default(&mut self, sym: &Symbol<'_>, id: ObjId) {
        let mut text = None;
        let mut bound = None;
        for tree in self.locator.syntax_trees() {
            if let Some(n) = sym.parameter_default_syntax(&tree) {
                text = Some(n.text().trim().to_owned());
                if let Some(scope) = sym.parent()
                    && let Some(e) = self.eval.bind_expression(n, scope)
                {
                    let e = unwrap_invalid_expr(e);
                    if !e.is_bad() {
                        bound = self.operand(&e);
                    }
                }
                break;
            }
        }
        let Some(text) = text else { return };
        let node = formal_default_node(&text);
        if matches!(node, ExprNode::Unsupported(_))
            && let Some(op) = bound
        {
            self.rel(id, consts::VPI_EXPR, op);
            return;
        }
        let e = self.model.add_expr(node);
        self.rel(id, consts::VPI_EXPR, Operand::Expr(e));
    }

    /// A type parameter's `vpiExpr` (37.28 detail 3): its default typespec.
    /// While the default applies, that is the parameter's own type; once an
    /// override replaced it the default type exists only as syntax and
    /// sv-lang cannot bind a type from syntax (SV-LANG PEER REQUEST), so the
    /// relation is a loud [`ExprNode::Unsupported`] rather than a wrong type.
    fn type_parameter_default(&mut self, sym: &Symbol<'_>, id: ObjId) {
        if sym.type_parameter_is_overridden() {
            let e = self.model.add_expr(ExprNode::Unsupported(format!(
                "the default typespec of the overridden type parameter {}",
                sym.name()
            )));
            self.rel(id, consts::VPI_EXPR, Operand::Expr(e));
        } else if let Some(ts) = sym.declared_type().and_then(|t| self.typespec(&t)) {
            self.rel(id, consts::VPI_EXPR, Operand::Obj(ts));
        }
    }

    /// A timing check (37.40) and its terms.
    fn tchk(&mut self, sym: &Symbol<'_>, parent: ObjId) {
        use sv_lang::SystemTimingCheckKind as K;
        let kind = sym.system_timing_check_kind();
        // (type, reference argument, data argument, notifier argument):
        // positions per the syntax of 31.3 and 31.4.
        let (ty, refi, datai, notifier) = match kind {
            K::Setup => ("vpiSetup", Some(1), Some(0), 3),
            K::Hold => ("vpiHold", Some(0), Some(1), 3),
            K::SetupHold => ("vpiSetupHold", Some(0), Some(1), 4),
            K::Recovery => ("vpiRecovery", Some(0), Some(1), 3),
            K::Removal => ("vpiRemoval", Some(0), Some(1), 3),
            K::RecRem => ("vpiRecrem", Some(0), Some(1), 4),
            K::Skew => ("vpiSkew", Some(0), Some(1), 3),
            K::TimeSkew => ("vpiTimeskew", Some(0), Some(1), 3),
            K::FullSkew => ("vpiFullskew", Some(0), Some(1), 4),
            K::Period => ("vpiPeriod", Some(0), None, 2),
            K::Width => ("vpiWidth", Some(0), None, 3),
            K::NoChange => ("vpiNoChange", Some(0), Some(1), 4),
            K::Unknown => return,
        };
        let mut obj = Obj::new(ObjKind::Tchk, Some(parent), "", "");
        obj.props.prim_type = header(ty);
        obj.props.path_key = self.body.clone().map(|b| (b, sym.uid()));
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(sym);
        let id = self.add(obj);
        let args: Vec<sv_lang::SystemTimingCheckArg<'_>> =
            sym.system_timing_check_arguments().collect();
        for (i, a) in args.iter().enumerate() {
            let is_event = Some(i) == refi || Some(i) == datai;
            let op = if is_event {
                let mut t = Obj::new(ObjKind::TchkTerm, Some(id), "", "");
                t.props.prim_type = crate::timingcheck::vpi_edge(a);
                t.props.file = Some(self.file.clone());
                t.props.line = self.locator.line(sym);
                let tid = self.add(t);
                if let Some(x) = a.expr {
                    let e = self.operand(&x);
                    self.fold_if_unmodelled(&x, e);
                    if let Some(e) = e {
                        self.rel(tid, consts::VPI_EXPR, e);
                    }
                }
                if let Some(x) = a.condition {
                    let c = self.operand(&x);
                    self.fold_if_unmodelled(&x, c);
                    if let Some(c) = c {
                        self.rel(tid, consts::VPI_CONDITION, c);
                    }
                }
                let rel = if Some(i) == refi {
                    "vpiTchkRefTerm"
                } else {
                    "vpiTchkDataTerm"
                };
                self.rel(id, header(rel), Operand::Obj(tid));
                Some(Operand::Obj(tid))
            } else {
                // The notifier is bound as the target of an assignment.
                let x = a.expr.map(|e| {
                    if e.kind() == sv_lang::kinds::ExpressionKind::Assignment {
                        e.left().unwrap_or(e)
                    } else {
                        e
                    }
                });
                let o = x.and_then(|e| self.operand(&e));
                if let Some(x) = x {
                    self.fold_if_unmodelled(&x, o);
                }
                o
            };
            if i == notifier
                && let Some(n) = op
            {
                self.rel(id, header("vpiTchkNotifier"), n);
            }
            if let Some(op) = op {
                self.rel(id, consts::VPI_EXPR, op);
            }
        }
    }

    /// The class typespec (37.32) of class type `ty` (a specialization):
    /// its defn, base typespec, class type and template.
    fn class_typespec(&mut self, ty: &Type<'_>, key: &str) -> Option<ObjId> {
        let sym = ty.as_symbol();
        let name = sym.name().to_owned();
        let mut obj = Obj::new(ObjKind::Typespec, None, &name, "");
        obj.props.stmt_type = header("vpiClassTypespec");
        // 37.32: a built-in class (a `std` package class) has no defn.
        let builtin = sym
            .parent()
            .is_some_and(|p| p.kind() == SymbolKind::Package && p.name() == "std");
        obj.props.class_type = header(match (builtin, name.as_str()) {
            (true, "mailbox") => "vpiMailboxClass",
            (true, "semaphore") => "vpiSemaphoreClass",
            (true, "process") => "vpiProcessClass",
            _ => "vpiUserDefinedClass",
        });
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(&sym);
        let id = self.add(obj);
        self.typespecs.insert(key.to_owned(), id);
        self.model
            .class_by_uid
            .insert(format!("{:?}", sym.uid()), id);
        if !builtin {
            let defn_sym = ty.class_generic_class().unwrap_or(sym);
            if let Some(defn) = self.class_defn(&defn_sym, Some(&sym), None) {
                self.rel(id, header("vpiClassDefn"), Operand::Obj(defn));
                self.rel(defn, header("vpiClassTypespec"), Operand::Obj(id));
            }
        }
        if let Some(base) = ty.class_base()
            && let Some(b) = self.typespec(&base)
        {
            self.rel(id, header("vpiExtends"), Operand::Obj(b));
        }
        Some(id)
    }

    /// The `constraint_mode` ordinals of class `c`'s constraint blocks, by
    /// name: base classes' blocks first, an override keeping the overridden
    /// block's place (as `vj_codegen`'s `class_constraint_blocks`).
    fn constraint_ordinals(c: &Symbol<'_>) -> std::collections::HashMap<String, u32> {
        let mut levels = vec![*c];
        let mut cur = c.as_type();
        while let Some(base) = cur.and_then(|t| t.class_base()) {
            levels.push(base.as_symbol());
            cur = Some(base);
        }
        levels.reverse();
        let mut names: Vec<String> = Vec::new();
        for level in levels {
            for m in level.members() {
                if m.kind() == SymbolKind::ConstraintBlock
                    && !m
                        .constraint_block_flags()
                        .contains(sv_lang::ConstraintBlockFlags::PURE)
                    && !names.iter().any(|n| n == m.name())
                {
                    names.push(m.name().to_owned());
                }
            }
        }
        names
            .into_iter()
            .enumerate()
            .map(|(i, n)| (n, i as u32))
            .collect()
    }

    /// A constraint block (37.34) of the class defn `parent` and its items.
    fn constraint_block(
        &mut self,
        m: &Symbol<'_>,
        parent: ObjId,
        full: &str,
        ordinals: &std::collections::HashMap<String, u32>,
        class_key: Option<&str>,
    ) {
        let flags = m.constraint_block_flags();
        let name = m.name().to_owned();
        let cfull = format!("{full}::{name}");
        let mut obj = Obj::new(ObjKind::Constraint, Some(parent), &name, &cfull);
        obj.props.virtual_ = flags.contains(sv_lang::ConstraintBlockFlags::PURE);
        obj.props.constraint_static = flags.contains(sv_lang::ConstraintBlockFlags::STATIC);
        obj.props.extern_ = flags.contains(sv_lang::ConstraintBlockFlags::EXTERN)
            || flags.contains(sv_lang::ConstraintBlockFlags::EXPLICIT_EXTERN);
        obj.props.constraint_ordinal = ordinals.get(&name).copied();
        if obj.props.constraint_static {
            obj.props.constraint_class_key = class_key.map(str::to_owned);
        }
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(m);
        let id = self.add(obj);
        if let Some(root) = m
            .constraint_block_constraints()
            .and_then(|n| n.as_constraint())
        {
            let trees = self.locator.syntax_trees();
            for item in self.constraint_items(root, &trees, id, &cfull) {
                self.rel(id, header("vpiConstraintItem"), item);
            }
        }
    }

    /// The `vpiWith` of a call (37.42 detail 1): an array locator method's
    /// `with` expression, or a `randomize` call's inline constraint block
    /// (an unnamed constraint object, 37.34).
    fn call_with(&mut self, e: &sv_lang::Expression<'_>) -> Option<Operand> {
        if let Some(w) = e.iterator_expr() {
            return self.operand(&w);
        }
        let root = e
            .randomize_inline_constraints()
            .and_then(|n| n.as_constraint())?;
        let n = self.inline_constraints;
        self.inline_constraints += 1;
        let full = format!("$with{n}");
        let mut obj = Obj::new(ObjKind::Constraint, None, "", &full);
        obj.props.file = Some(self.file.clone());
        let id = self.add(obj);
        let trees = self.locator.syntax_trees();
        for item in self.constraint_items(root, &trees, id, &full) {
            self.rel(id, header("vpiConstraintItem"), item);
        }
        Some(Operand::Obj(id))
    }

    /// The syntax node of constraint `c`.
    fn constraint_syntax<'t>(
        c: &sv_lang::Constraint<'_>,
        trees: &'t [SyntaxTree],
    ) -> Option<sv_lang::Node<'t>> {
        trees.iter().find_map(|t| c.syntax(t))
    }

    /// The items constraint `c` stands for (a list is its members, 37.38).
    fn constraint_items(
        &mut self,
        c: sv_lang::Constraint<'_>,
        trees: &[SyntaxTree],
        owner: ObjId,
        owner_full: &str,
    ) -> Vec<Operand> {
        use sv_lang::AstNode;
        use sv_lang::kinds::ConstraintKind as C;
        let kids = c.children();
        let sub_constraints: Vec<sv_lang::Constraint<'_>> =
            kids.iter().filter_map(|n| n.as_constraint()).collect();
        let exprs: Vec<sv_lang::Expression<'_>> =
            kids.iter().filter_map(|n| n.as_expression()).collect();
        let items_of = |s: &mut Self, k: Option<&sv_lang::Constraint<'_>>| -> Vec<Operand> {
            k.map_or_else(Vec::new, |k| {
                s.constraint_items(*k, trees, owner, owner_full)
            })
        };
        let node = |s: &mut Self, n: ExprNode| Operand::Expr(s.model.add_expr(n));
        let unsupported = |s: &mut Self, what: String| {
            Operand::Expr(s.model.add_expr(ExprNode::Unsupported(what)))
        };
        match c.kind() {
            C::List => sub_constraints
                .iter()
                .flat_map(|k| self.constraint_items(*k, trees, owner, owner_full))
                .collect(),
            C::Expression => {
                let Some(e) = c.expr() else { return Vec::new() };
                let soft = Self::constraint_syntax(&c, trees)
                    .and_then(sv_lang::nodes::ExpressionConstraintSyntax::cast)
                    .is_some_and(|s| s.soft().is_some());
                if e.kind() == sv_lang::kinds::ExpressionKind::Dist {
                    let Some(left) = e.dist_left().and_then(|l| self.operand(&l)) else {
                        return Vec::new();
                    };
                    let mut items = Vec::new();
                    for it in e.dist_items() {
                        let Some(value) = self.operand(&it.value()) else {
                            continue;
                        };
                        let w = it.weight();
                        let weight = w.as_ref().and_then(|w| self.operand(&w.expr));
                        let div = w.is_some_and(|w| w.kind == sv_lang::DistWeightKind::PerRange);
                        items.push(node(self, ExprNode::DistItem { value, weight, div }));
                    }
                    return vec![node(
                        self,
                        ExprNode::Distribution {
                            expr: left,
                            items,
                            soft,
                        },
                    )];
                }
                let Some(op) = self.operand(&e) else {
                    return Vec::new();
                };
                if soft
                    && let Operand::Expr(x) = op
                    && let Some(ExprNode::Op { meta, .. }) = self.model.expr_mut(x)
                {
                    meta.soft = true;
                }
                vec![op]
            }
            C::Implication => {
                let Some(cond) = c.predicate().and_then(|p| self.operand(&p)) else {
                    return Vec::new();
                };
                let body = items_of(self, sub_constraints.first());
                vec![node(self, ExprNode::Implication { cond, body })]
            }
            C::Conditional => {
                let Some(cond) = c.predicate().and_then(|p| self.operand(&p)) else {
                    return Vec::new();
                };
                let body = items_of(self, sub_constraints.first());
                let els = sub_constraints.get(1).map(|k| items_of(self, Some(k)));
                vec![node(self, ExprNode::ConstrIf { cond, body, els })]
            }
            C::Foreach => {
                let Some(array) = exprs.first().and_then(|a| self.operand(a)) else {
                    return Vec::new();
                };
                let names: Vec<String> = Self::constraint_syntax(&c, trees)
                    .and_then(sv_lang::nodes::LoopConstraintSyntax::cast)
                    .map(|l| {
                        l.loop_list()
                            .loop_variables()
                            .iter()
                            .map(|v| v.syntax().text().trim().to_string())
                            .collect()
                    })
                    .unwrap_or_default();
                let mut vars = Vec::new();
                for n in names {
                    if n.is_empty() {
                        vars.push(node(
                            self,
                            ExprNode::Op {
                                op_type: header("vpiNullOp"),
                                width: 0,
                                operands: Vec::new(),
                                meta: OpMeta::default(),
                            },
                        ));
                        continue;
                    }
                    let mut v = Obj::new(
                        ObjKind::IntVar,
                        Some(owner),
                        &n,
                        &format!("{owner_full}.{n}"),
                    );
                    v.props.width = 32;
                    v.props.signed = true;
                    v.props.automatic = true;
                    v.props.file = Some(self.file.clone());
                    let vid = self.add(v);
                    vars.push(Operand::Obj(vid));
                }
                let mark = self.loop_vars.len();
                for v in &vars {
                    if let Operand::Obj(id) = v
                        && let Some(o) = self.model.get(*id)
                    {
                        self.loop_vars.push((o.name.clone(), *id));
                    }
                }
                let body = items_of(self, sub_constraints.first());
                self.loop_vars.truncate(mark);
                vec![node(self, ExprNode::ConstrForeach { array, vars, body })]
            }
            C::SolveBefore => {
                let n_before = Self::constraint_syntax(&c, trees)
                    .and_then(sv_lang::nodes::SolveBeforeConstraintSyntax::cast)
                    .map_or(exprs.len(), |s| s.before_expr().iter().count());
                let ops: Vec<Operand> = exprs.iter().filter_map(|e| self.operand(e)).collect();
                let split = n_before.min(ops.len());
                let (before, after) = ops.split_at(split);
                vec![node(
                    self,
                    ExprNode::ConstrOrdering {
                        before: before.to_vec(),
                        after: after.to_vec(),
                    },
                )]
            }
            C::DisableSoft => match exprs.first().and_then(|e| self.operand(e)) {
                Some(expr) => vec![node(self, ExprNode::SoftDisable { expr })],
                None => Vec::new(),
            },
            other => vec![unsupported(
                self,
                format!("a {other:?} constraint (37.38 has no object for it)"),
            )],
        }
    }

    /// The class defn (37.31) of `defn` (a class or a generic class), its
    /// contents built from `content` (the class itself, or one of the
    /// generic class's specializations) the first time one is given.
    /// `scope`: the scope declaring it (a `$unit` class has none).
    fn class_defn(
        &mut self,
        defn: &Symbol<'_>,
        content: Option<&Symbol<'_>>,
        scope: Option<(ObjId, &str)>,
    ) -> Option<ObjId> {
        let key = format!("classdefn:{:?}", defn.uid());
        let id = match self.typespecs.get(&key) {
            Some(&id) => id,
            None => {
                let name = defn.name().to_owned();
                let full = scope.map_or(name.clone(), |(_, n)| format!("{n}.{name}"));
                let mut obj = Obj::new(ObjKind::ClassDefn, scope.map(|(p, _)| p), &name, &full);
                obj.props.file = Some(self.file.clone());
                obj.props.line = self.locator.line(defn);
                let id = self.add(obj);
                self.typespecs.insert(key.clone(), id);
                id
            }
        };
        let built = format!("{key}:built");
        if let Some(c) = content
            && !self.typespecs.contains_key(&built)
        {
            self.typespecs.insert(built, id);
            self.class_contents(c, id);
        }
        Some(id)
    }

    /// A class defn's contents from class `c` (37.31): properties
    /// (variables without values), methods, parameters, typedefs, `extends`.
    fn class_contents(&mut self, c: &Symbol<'_>, id: ObjId) {
        let full = self
            .model
            .get(id)
            .map(|o| o.full_name.clone())
            .unwrap_or_default();
        if let Some(t) = c.as_type()
            && let Some(p) = self.model.props_mut(id)
        {
            p.virtual_ = t.class_is_abstract();
        }
        let layout = vj_codegen::classes::ObjectLayout::for_template(*c).ok();
        for m in c.members() {
            match m.kind() {
                SymbolKind::ClassProperty => {
                    let Some(ty) = m.value_type() else { continue };
                    let name = m.name().to_owned();
                    let mut v = Obj::new(
                        Self::data_kind(&ty, false),
                        Some(id),
                        &name,
                        &format!("{full}::{name}"),
                    );
                    Self::fill_scalar_props(&mut v.props, &ty);
                    v.props.automatic = m.variable_lifetime() == VariableLifetime::Automatic;
                    v.props.visibility = match m.class_property_visibility() {
                        sv_lang::Visibility::Protected => header("vpiProtectedVis"),
                        sv_lang::Visibility::Local => header("vpiLocalVis"),
                        sv_lang::Visibility::Public => 0,
                    };
                    v.props.field_slot = layout
                        .as_ref()
                        .and_then(|l| l.slot_of(&m))
                        .map(|s| (s.offset, s.words));
                    v.props.file = Some(self.file.clone());
                    v.props.line = self.locator.line(&m);
                    let vid = self.add(v);
                    self.prop_by_uid.insert(m.uid(), vid);
                    self.typespec_rel(vid, Some(ty));
                }
                SymbolKind::Subroutine
                    if !m
                        .subroutine_flags()
                        .contains(sv_lang::MethodFlags::BUILT_IN) =>
                {
                    self.task_func(&m, id, &full, "::");
                }
                SymbolKind::Parameter => self.parameter(&m, id, &full),
                SymbolKind::TypeAlias => {
                    if let Some(ts) = m.as_type().and_then(|t| self.typespec(&t)) {
                        self.rel(id, header("vpiTypedef"), Operand::Obj(ts));
                    }
                }
                _ => {}
            }
        }
        if let Some(t) = c.as_type()
            && let Some(base) = t.class_base()
        {
            let mut e = Obj::new(ObjKind::Extends, Some(id), "", "");
            e.props.file = Some(self.file.clone());
            let eid = self.add(e);
            if let Some(b) = self.typespec(&base) {
                self.rel(eid, header("vpiClassTypespec"), Operand::Obj(b));
                // The base's defn lists this one among its derived classes.
                let base_defn = self.model.get(b).and_then(|o| {
                    o.props
                        .rels
                        .iter()
                        .find(|(k, _)| *k == header("vpiClassDefn"))
                        .map(|(_, t)| *t)
                });
                if let Some(Operand::Obj(bd)) = base_defn {
                    self.rel(bd, header("vpiDerivedClasses"), Operand::Obj(id));
                }
            }
            if let Some(call) = t.class_base_constructor_call() {
                for a in call.operands() {
                    if let Some(op) = self.operand(&a) {
                        self.rel(eid, consts::VPI_ARGUMENT, op);
                    }
                }
            }
            self.rel(id, header("vpiExtends"), Operand::Obj(eid));
        }
        // Its constraint blocks, after its properties and its base class's (37.34 detail 4: in
        // declaration order).
        let ordinals = Self::constraint_ordinals(c);
        let class_key = c.as_type().map(vj_sim::netlist::class_specialization_key);
        for m in c.members() {
            if m.kind() == SymbolKind::ConstraintBlock {
                self.constraint_block(&m, id, &full, &ordinals, class_key.as_deref());
            }
        }
    }

    /// A `property` or `sequence` declaration (37.51, 37.53) and its formals.
    fn assertion_decl(&mut self, sym: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        let property = sym.kind() == SymbolKind::Property;
        let name = sym.name().to_owned();
        let full = format!("{parent_name}.{name}");
        let mut obj = Obj::new(
            if property {
                ObjKind::PropertyDecl
            } else {
                ObjKind::SequenceDecl
            },
            Some(parent),
            &name,
            &full,
        );
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(sym);
        let id = self.add(obj);
        self.formal_names.clear();
        let mut formals: Vec<(Symbol<'_>, ObjId)> = Vec::new();
        let ports: Vec<Symbol<'_>> = if property {
            sym.property_ports().collect()
        } else {
            sym.sequence_ports().collect()
        };
        for p in ports {
            let pname = p.name().to_owned();
            let mut f = Obj::new(
                if property {
                    ObjKind::PropFormalDecl
                } else {
                    ObjKind::SeqFormalDecl
                },
                Some(id),
                &pname,
                &format!("{full}.{pname}"),
            );
            // 37.51 detail 5, 37.53 detail 4: a local variable argument has
            // its direction, any other formal none.
            f.props.direction = if p.assertion_port_is_local_var() {
                match p.assertion_port_direction() {
                    Some(ArgumentDirection::Out) => consts::VPI_OUTPUT,
                    Some(ArgumentDirection::InOut) => consts::VPI_INOUT,
                    _ => consts::VPI_INPUT,
                }
            } else {
                header("vpiNoDirection")
            };
            f.props.file = Some(self.file.clone());
            f.props.line = self.locator.line(&p);
            let fid = self.add(f);
            self.formal_by_uid.insert(p.uid(), fid);
            self.formal_names.push((pname, fid));
            formals.push((p, fid));
            // An untyped formal has no typespec (37.51 detail 3).
            if let Some(t) = p.declared_type().filter(|t| !t.is_untyped_type()) {
                self.typespec_rel(fid, Some(t));
            }
        }
        // The body slang bound in the declaration's own scope: an
        // `AssertionInstance` whose arguments carry the formals' defaults
        // bound in context (a non-literal default has no other form).
        let scope_sym = sym.parent().unwrap_or(*sym);
        let trees = self.locator.syntax_trees();
        let bound = sym.bound_body().map(unwrap_invalid_expr);
        let body = bound.and_then(|b| {
            b.as_sem_node()
                .children_with_invalid()
                .into_iter()
                .find_map(|n| n.as_assertion_expr())
        });
        self.decl_locals(sym, id, &full, body, property);
        // slang substitutes a defaulted formal's bound default into the
        // body, so a non-literal default is the expression in the body
        // written at the default's source range.
        let mut defaults = std::collections::HashMap::new();
        if let Some(body) = body {
            for (p, _) in &formals {
                let Some(range) = trees
                    .iter()
                    .find_map(|t| p.assertion_port_default_syntax(t).map(|n| n.byte_range()))
                else {
                    continue;
                };
                let Some(e) = Self::expr_at_range(body.as_sem_node(), &range) else {
                    continue;
                };
                if let Some(op) = self.leaf_operand(&e, &trees, &scope_sym) {
                    defaults.insert(p.uid(), op);
                }
            }
        }
        for (p, fid) in &formals {
            self.formal_default(p, *fid, defaults.get(&p.uid()).copied(), &scope_sym);
        }
        self.formals_by_text = true;
        self.decl_parent = Some(id);
        let real = body.is_some_and(|body| self.assertion_decl_real_body(sym, id, property, body));
        self.decl_parent = None;
        self.formal_names.clear();
        self.formals_by_text = false;
        if !real {
            self.assertion_decl_body(sym, id, property);
        }
    }

    /// The local variables a `sequence` or `property` declaration declares
    /// (`logic v;` in its body; 37.51, 37.53 `vpiVariables`), in declaration
    /// order, as lexical objects under the declaration: a local assertion
    /// variable lives per evaluation attempt, so like an automatic variable it
    /// has no value to read. slang reaches the variable's symbol (hence its
    /// type) only through a reference in the bound body, so a declared
    /// variable the body never mentions gets no object: its name is kept in
    /// `Props::unbound_locals` and the iteration refuses by name instead of
    /// omitting it.
    fn decl_locals(
        &mut self,
        sym: &Symbol<'_>,
        id: ObjId,
        full: &str,
        body: Option<sv_lang::AssertionExpr<'_>>,
        property: bool,
    ) {
        use sv_lang::AstNode;
        let mut declared: Vec<String> = Vec::new();
        for tree in self.locator.syntax_trees() {
            let Some(node) = sym.syntax(&tree) else {
                continue;
            };
            let lists = if property {
                sv_lang::nodes::PropertyDeclarationSyntax::cast(node).map(|d| d.variables())
            } else {
                sv_lang::nodes::SequenceDeclarationSyntax::cast(node).map(|d| d.variables())
            };
            let Some(lists) = lists else { continue };
            for decl in lists.into_iter() {
                for d in decl.declarators().into_iter() {
                    if let Some(n) = d.name() {
                        declared.push(n.text().to_owned());
                    }
                }
            }
            break;
        }
        if declared.is_empty() {
            return;
        }
        fn find<'d>(n: sv_lang::SemNode<'d>, out: &mut Vec<Symbol<'d>>) {
            if let Some(e) = n.as_expression()
                && let Some(s) = e.referenced_symbol()
                && s.kind() == SymbolKind::LocalAssertionVar
                && !out.iter().any(|o| o.uid() == s.uid())
            {
                out.push(s);
            }
            for k in n.children_with_invalid() {
                find(k, out);
            }
        }
        let mut seen = Vec::new();
        if let Some(b) = body {
            find(b.as_sem_node(), &mut seen);
        }
        let mut unbound = Vec::new();
        for name in declared {
            let Some(v) = seen.iter().find(|s| s.name() == name) else {
                unbound.push(name);
                continue;
            };
            let first = self.model.len() as ObjId;
            self.data(v, id, full, false);
            let last = self.model.len() as ObjId;
            for o in first..last {
                if let Some(p) = self.model.props_mut(o) {
                    p.automatic = true;
                }
            }
            if first < last {
                self.prop_by_uid.insert(v.uid(), first);
            }
        }
        if !unbound.is_empty()
            && let Some(p) = self.model.props_mut(id)
        {
            p.unbound_locals = unbound;
        }
    }

    /// Whether every expression leaf at or below `n` lies inside `range`
    /// (`None` when there is none): a bound default keeps its leaves'
    /// source ranges while its own range is the use site's.
    fn leaves_within(n: &sv_lang::SemNode<'_>, range: &std::ops::Range<usize>) -> Option<bool> {
        let kids: Vec<_> = n.children_with_invalid();
        if kids.iter().all(|k| k.as_expression().is_none())
            && let Some(e) = n.as_expression()
        {
            let r = e.source_range();
            let (s, t) = (r.start.offset as usize, r.end.offset as usize);
            return Some(t > s && s >= range.start && t <= range.end);
        }
        let mut seen = None;
        for k in &kids {
            match Self::leaves_within(k, range) {
                Some(false) => return Some(false),
                Some(true) => seen = Some(true),
                None => {}
            }
        }
        seen
    }

    /// The outermost expression below `n` made only of source inside
    /// `range` (a formal's default substituted into a declaration's bound
    /// body).
    fn expr_at_range<'d>(
        n: sv_lang::SemNode<'d>,
        range: &std::ops::Range<usize>,
    ) -> Option<sv_lang::Expression<'d>> {
        for k in n.children_with_invalid() {
            if let Some(e) = k.as_expression()
                && e.kind() != sv_lang::kinds::ExpressionKind::Invalid
                && Self::leaves_within(&k, range) == Some(true)
            {
                return Some(e);
            }
            if let Some(e) = Self::expr_at_range(k, range) {
                return Some(e);
            }
        }
        None
    }

    /// The bound body `body` of a `property` or `sequence` declaration as
    /// real objects (37.51, 37.53): a property's clocking event and
    /// `disable iff` are peeled onto its spec (16.12). False when the body
    /// cannot be modelled, so the caller falls back to the opaque node.
    fn assertion_decl_real_body(
        &mut self,
        sym: &Symbol<'_>,
        id: ObjId,
        property: bool,
        body: sv_lang::AssertionExpr<'_>,
    ) -> bool {
        use sv_lang::kinds::AssertionExprKind as A;
        let scope_sym = sym.parent().unwrap_or(*sym);
        let trees = self.locator.syntax_trees();
        let mut body = body;
        let mut clock = None;
        let mut disable = None;
        if property {
            loop {
                match body.kind() {
                    A::Clocking => {
                        let Ok(c) = vj_codegen::sva_shape::op::clocking_children(body, &scope_sym)
                        else {
                            break;
                        };
                        clock = c
                            .event
                            .as_timing_control()
                            .and_then(|t| self.event_operand(&t));
                        body = c.body;
                    }
                    A::DisableIff => {
                        let Ok(d) =
                            vj_codegen::sva_shape::op::disable_iff_children(body, &scope_sym)
                        else {
                            break;
                        };
                        disable = d.condition.as_expression().and_then(|e| self.operand(&e));
                        body = d.body;
                    }
                    _ => break,
                }
            }
        }
        let saved = std::mem::replace(&mut self.ctx_clock, clock);
        let expr = self.prop_expr(body, &trees, &scope_sym);
        self.ctx_clock = saved;
        let Some(expr) = expr else { return false };
        if property {
            let mut ps = Obj::new(ObjKind::PropertySpec, Some(id), "", "");
            ps.props.file = Some(self.file.clone());
            ps.props.line = self.locator.line(sym);
            let ps_id = self.add(ps);
            if let Some(c) = clock {
                self.rel(ps_id, header("vpiClockingEvent"), c);
            }
            if let Some(d) = disable {
                self.rel(ps_id, header("vpiDisableCondition"), d);
            }
            self.rel(ps_id, header("vpiPropertyExpr"), expr);
            self.rel(id, header("vpiProperty"), Operand::Obj(ps_id));
        } else {
            self.rel(id, consts::VPI_EXPR, expr);
        }
        true
    }

    /// The body of a `property` or `sequence` declaration (37.51, 37.53): a
    /// property declaration's `vpiProperty` is a property spec whose
    /// `vpiPropertyExpr` is the body, a sequence declaration's `vpiExpr` is
    /// the body. slang binds a declaration's body only where it is
    /// instantiated (with the formals substituted), so the body is an
    /// opaque node carrying its source text: the handle navigates, any read
    /// of it fails loudly naming the text.
    fn assertion_decl_body(&mut self, sym: &Symbol<'_>, id: ObjId, property: bool) {
        use sv_lang::AstNode;
        let mut text = None;
        for tree in self.locator.syntax_trees() {
            let Some(node) = sym.syntax(&tree) else {
                continue;
            };
            let full = if property {
                sv_lang::nodes::PropertyDeclarationSyntax::cast(node)
                    .map(|n| n.syntax().text().to_owned())
            } else {
                sv_lang::nodes::SequenceDeclarationSyntax::cast(node)
                    .map(|n| n.syntax().text().to_owned())
            };
            if let Some(full) = full {
                text = Some(full);
                break;
            }
        }
        let Some(full) = text else { return };
        // After the header's `;` (outside the formal list's parentheses),
        // before the closing keyword.
        let mut depth = 0i32;
        let mut start = None;
        for (i, c) in full.char_indices() {
            match c {
                '(' => depth += 1,
                ')' => depth -= 1,
                ';' if depth == 0 => {
                    start = Some(i + 1);
                    break;
                }
                _ => {}
            }
        }
        let end_kw = if property {
            "endproperty"
        } else {
            "endsequence"
        };
        let (Some(start), Some(end)) = (start, full.rfind(end_kw)) else {
            return;
        };
        let body = full[start..end.max(start)]
            .trim()
            .trim_end_matches(';')
            .trim()
            .to_owned();
        let kind = if property { "property" } else { "sequence" };
        let e = self.model.add_expr(ExprNode::Unsupported(format!(
            "the body `{body}` of a {kind} declaration (slang binds it only at an instance)"
        )));
        if property {
            let mut ps = Obj::new(ObjKind::PropertySpec, Some(id), "", "");
            ps.props.file = Some(self.file.clone());
            ps.props.line = self.locator.line(sym);
            let ps_id = self.add(ps);
            self.rel(ps_id, header("vpiPropertyExpr"), Operand::Expr(e));
            self.rel(id, header("vpiProperty"), Operand::Obj(ps_id));
        } else {
            self.rel(id, consts::VPI_EXPR, Operand::Expr(e));
        }
    }

    /// A statement's source span: 1-based start line and column, end line
    /// and column.
    fn span_of(&self, stmt: &Statement<'_>) -> Option<(i32, i32, i32, i32)> {
        for (tree, starts) in &self.locator.trees {
            if let Some(node) = stmt.syntax(tree) {
                let r = node.byte_range();
                let at = |o: usize| {
                    let line = starts.partition_point(|&s| s <= o);
                    (line as i32, (o - starts[line - 1]) as i32 + 1)
                };
                let (sl, sc) = at(r.start);
                let (el, ec) = at(r.end.saturating_sub(1).max(r.start));
                return Some((sl, sc, el, ec));
            }
        }
        None
    }

    /// An assertion's location, action statements and, for a concurrent one,
    /// its property spec (37.49, 37.50, 37.52).
    fn assertion_structure(
        &mut self,
        stmt: &Statement<'_>,
        id: ObjId,
        scope: &str,
        block: &Symbol<'_>,
    ) {
        let span = self.span_of(stmt);
        if let Some(p) = self.model.props_mut(id) {
            p.span = span;
        }
        let concurrent = stmt.kind() == StatementKind::ConcurrentAssertion;
        let (then, els) = if concurrent {
            (stmt.assertion_if_true(), stmt.assertion_if_false())
        } else {
            (
                stmt.immediate_assertion_if_true(),
                stmt.immediate_assertion_if_false(),
            )
        };
        // 37.50: a `restrict` has no action block, so no `vpiStmt` (the
        // parser gives it an empty statement, which is not an object here).
        let no_action = concurrent && stmt.assertion_kind() == Some(AssertionKind::Restrict);
        if !no_action
            && let Some(t) = then
            && let Some(s) = self.stmt(&t, id, scope)
        {
            self.rel(id, consts::VPI_STMT, Operand::Obj(s));
        }
        if let Some(e) = els
            && let Some(s) = self.stmt(&e, id, scope)
        {
            self.rel(id, consts::VPI_ELSE_STMT, Operand::Obj(s));
        }
        if !concurrent {
            // An immediate assertion's condition (37.55).
            if let Some(c) = stmt.children().into_iter().find_map(|n| n.as_expression())
                && let Some(op) = self.operand(&c)
            {
                self.rel(id, consts::VPI_EXPR, op);
            }
            return;
        }
        let cover_seq = stmt.assertion_kind() == Some(AssertionKind::CoverSequence);
        let Some(spec) = stmt
            .children()
            .into_iter()
            .find_map(|n| n.as_assertion_expr())
        else {
            return;
        };
        let outer = self.cur_assertion.replace(id);
        let scope_sym = block.parent().unwrap_or(*block);
        let trees = self.locator.syntax_trees();
        // Peel the spec's clocking event and `disable iff` (16.12).
        let mut body = spec;
        let mut clock = None;
        let mut disable = None;
        loop {
            match body.kind() {
                sv_lang::kinds::AssertionExprKind::Clocking => {
                    let Ok(c) = vj_codegen::sva_shape::op::clocking_children(body, &scope_sym)
                    else {
                        break;
                    };
                    clock = c
                        .event
                        .as_timing_control()
                        .and_then(|t| self.event_operand(&t));
                    body = c.body;
                }
                sv_lang::kinds::AssertionExprKind::DisableIff => {
                    let Ok(d) = vj_codegen::sva_shape::op::disable_iff_children(body, &scope_sym)
                    else {
                        break;
                    };
                    disable = d.condition.as_expression().and_then(|e| self.operand(&e));
                    body = d.body;
                }
                _ => break,
            }
        }
        let saved = std::mem::replace(&mut self.ctx_clock, clock);
        let expr = self.prop_expr(body, &trees, &scope_sym);
        self.ctx_clock = saved;
        let mut ps = Obj::new(ObjKind::PropertySpec, Some(id), "", "");
        ps.props.file = Some(self.file.clone());
        ps.props.line = span.map_or(0, |s| s.0);
        let ps_id = self.add(ps);
        if let Some(c) = clock {
            self.rel(ps_id, header("vpiClockingEvent"), c);
        }
        // 37.50 detail 1: the assertion's clocking event is the one it is
        // evaluated on, written or inferred (16.14.6): a clocked property
        // instance's own, the procedure's, then the default clocking (14.12).
        let actual = match clock {
            Some(c) => Some(c),
            None => {
                let leading = Self::leading_instance_clock(body, &scope_sym);
                let procedural = || {
                    (block.kind() == SymbolKind::ProceduralBlock)
                        .then(|| {
                            vj_sim::analysis::infer_structural_clock(block)
                                .ok()
                                .flatten()
                        })
                        .flatten()
                };
                match leading.or_else(procedural) {
                    Some(t) => self.event_operand(&t),
                    None => {
                        let default = trees.iter().find_map(|t| {
                            vj_sim::state::default_clocking_of(block, t).ok().flatten()
                        });
                        default
                            .and_then(|cb| cb.clocking_block_event())
                            .and_then(|n| n.as_timing_control())
                            .and_then(|t| self.event_operand(&t))
                    }
                }
            }
        };
        if let Some(c) = actual {
            self.rel(id, header("vpiClockingEvent"), c);
        }
        if let Some(d) = disable {
            self.rel(ps_id, header("vpiDisableCondition"), d);
            self.rel(id, header("vpiDisableCondition"), d);
        }
        if let Some(e) = expr {
            self.rel(ps_id, header("vpiPropertyExpr"), e);
        }
        self.rel(id, header("vpiProperty"), Operand::Obj(ps_id));
        if let Some(p) = self.model.props_mut(id) {
            p.clock_inferred = clock.is_none();
            p.cover_sequence = cover_seq;
        }
        self.cur_assertion = outer;
    }

    fn leading_instance_clock<'d>(
        mut e: sv_lang::AssertionExpr<'d>,
        scope: &Symbol<'d>,
    ) -> Option<sv_lang::TimingControl<'d>> {
        use sv_lang::kinds::AssertionExprKind as A;
        loop {
            match e.kind() {
                A::Clocking => {
                    let c = vj_codegen::sva_shape::op::clocking_children(e, scope).ok()?;
                    return c.event.as_timing_control();
                }
                A::Simple => {
                    let x = e.children().into_iter().find_map(|n| n.as_expression())?;
                    if x.kind() != sv_lang::kinds::ExpressionKind::AssertionInstance {
                        return None;
                    }
                    e = x
                        .as_sem_node()
                        .children()
                        .into_iter()
                        .find_map(|n| n.as_assertion_expr())?;
                }
                _ => return None,
            }
        }
    }

    /// An event expression as an operand: `posedge x` / `negedge x` are
    /// `vpiPosedgeOp` / `vpiNegedgeOp` operations, a list a `vpiListOp`.
    fn event_operand(&mut self, t: &sv_lang::TimingControl<'_>) -> Option<Operand> {
        use sv_lang::kinds::TimingControlKind as T;
        match t.kind() {
            T::SignalEvent => {
                let e = t.children().into_iter().find_map(|n| n.as_expression())?;
                let op = self.operand(&e)?;
                let edge = match t.edge() {
                    sv_lang::EdgeKind::PosEdge => Some("vpiPosedgeOp"),
                    sv_lang::EdgeKind::NegEdge => Some("vpiNegedgeOp"),
                    sv_lang::EdgeKind::BothEdges => Some("vpiAnyEdge"),
                    _ => None,
                };
                Some(match edge {
                    Some(name) if consts::value_of(name).is_some() && name != "vpiAnyEdge" => {
                        Operand::Expr(self.model.add_expr(ExprNode::Op {
                            op_type: header(name),
                            width: 1,
                            operands: vec![op],
                            meta: OpMeta::default(),
                        }))
                    }
                    _ => op,
                })
            }
            T::EventList => {
                let ops: Vec<Operand> = t
                    .children()
                    .into_iter()
                    .filter_map(|n| n.as_timing_control())
                    .filter_map(|c| self.event_operand(&c))
                    .collect();
                Some(Operand::Expr(self.model.add_expr(ExprNode::Op {
                    op_type: header("vpiListOp"),
                    width: 1,
                    operands: ops,
                    meta: OpMeta::default(),
                })))
            }
            _ => None,
        }
    }

    /// A constant operand of value `v` (a range bound); `None` is `$`.
    fn bound(&mut self, v: Option<u32>) -> Operand {
        Operand::Expr(self.model.add_expr(match v {
            Some(v) => ExprNode::Const {
                value: Logic::from_u64(u64::from(v), 32),
                signed: true,
                const_type: header("vpiDecConst"),
            },
            None => ExprNode::Const {
                value: Logic::zero(1),
                signed: false,
                const_type: header("vpiUnboundedConst"),
            },
        }))
    }

    /// An operation node.
    fn op_node(&mut self, name: &str, operands: Vec<Operand>, strong: bool) -> Operand {
        Operand::Expr(self.model.add_expr(ExprNode::Op {
            op_type: header(name),
            width: 1,
            operands,
            meta: OpMeta {
                strong,
                ..OpMeta::default()
            },
        }))
    }

    /// `( sequence_expr { , match_item } ) [ sequence_abbrev ]` (16.7, 37.54):
    /// the repetition, if any, is a `[*]`/`[=]`/`[->]` operation over the
    /// parenthesized sequence; match items hang off the sequence as
    /// `vpiMatchItem` (assignments and task/function calls). 37.54 detail 2
    /// lists no `vpiOpType` for a sequence that carries match items, so such a
    /// sequence is a `vpiListOp` operation (the parenthesized comma list it is
    /// written as) whose one `vpiOperand` is the sequence.
    fn sequence_with_match(
        &mut self,
        e: sv_lang::AssertionExpr<'_>,
        kids: Vec<sv_lang::SemNode<'_>>,
        trees: &[SyntaxTree],
        scope: &Symbol<'_>,
    ) -> Option<Operand> {
        use sv_lang::AstNode;
        use vj_codegen::sva_shape::{ranges, trees::Trees};
        let unsupported = |s: &mut Self, what: &str| {
            Some(Operand::Expr(
                s.model.add_expr(ExprNode::Unsupported(what.into())),
            ))
        };
        let Some(syn) = Trees::new(trees).syntax(&e) else {
            return unsupported(self, "a parenthesized sequence without a syntax node");
        };
        let Some(paren) = sv_lang::nodes::ParenthesizedSequenceExprSyntax::cast(
            ranges::peel_sequence_parens(syn),
        ) else {
            return unsupported(
                self,
                "a sequence-with-match that is not a parenthesized sequence",
            );
        };
        let sub = kids.iter().find_map(|k| k.as_assertion_expr())?;
        let mut inner = self.prop_expr(sub, trees, scope)?;
        let parent = self.cur_assertion.or(self.decl_parent);
        let mut items = Vec::new();
        for k in kids.iter().filter(|k| k.as_assertion_expr().is_none()) {
            let Some(x) = k.as_expression() else {
                return unsupported(self, "a sequence match item that is not an expression");
            };
            let item = parent
                .and_then(|p| self.for_clause_stmt(&x, p))
                .map(Operand::Obj)
                .or_else(|| self.operand(&x));
            items.push(item?);
        }
        if !items.is_empty() {
            let w = self.op_node("vpiListOp", vec![inner], false);
            if let Operand::Expr(id) = w
                && let Some(ExprNode::Op { meta, .. }) = self.model.expr_mut(id)
            {
                meta.match_items = items;
            }
            inner = w;
        }
        let Some(rep) = paren.repetition() else {
            return Some(inner);
        };
        let r = match ranges::repetition_range(rep, scope) {
            Ok(r) => r,
            Err(_) => {
                return unsupported(self, "a sequence repetition whose bounds are not constants");
            }
        };
        let name = match rep.op().map(|t| t.text()) {
            Some("->") => "vpiGotoRepeatOp",
            Some("=") => "vpiRepeatOp",
            _ => "vpiConsecutiveRepeatOp",
        };
        let mut ops = vec![inner, self.bound(Some(r.min))];
        if r.max != Some(r.min) {
            ops.push(self.bound(r.max));
        }
        Some(self.op_node(name, ops, false))
    }

    /// The source text of assertion expression `e`.
    fn assertion_text(trees: &[SyntaxTree], e: &sv_lang::AssertionExpr<'_>) -> String {
        trees
            .iter()
            .find_map(|t| e.syntax(t).map(|n| n.text()))
            .unwrap_or_default()
    }

    /// The range of `[lo:hi]` written right after operator keyword `kw` in
    /// `text` (`nexttime [2]`, `always [1:$]`), when both bounds are integer
    /// literals.
    fn keyword_range(text: &str, kw: &str) -> Option<(u32, Option<u32>, bool)> {
        let at = text.find(kw)? + kw.len();
        let rest = text[at..].trim_start();
        let inner = rest.strip_prefix('[')?;
        let inner = &inner[..inner.find(']')?];
        let mut parts = inner.split(':').map(str::trim);
        let lo: u32 = parts.next()?.parse().ok()?;
        match parts.next() {
            None => Some((lo, Some(lo), false)),
            Some("$") => Some((lo, None, true)),
            Some(h) => Some((lo, Some(h.parse().ok()?), true)),
        }
    }

    /// A property or sequence expression (37.52, 37.54) as an operand.
    fn prop_expr(
        &mut self,
        e: sv_lang::AssertionExpr<'_>,
        trees: &[SyntaxTree],
        scope: &Symbol<'_>,
    ) -> Option<Operand> {
        use sv_lang::kinds::AssertionExprKind as A;
        use vj_codegen::sva_shape::op::{AssertionBinaryOp as B, AssertionUnaryOp as U, Op};
        let kids = e.as_sem_node().children_with_invalid();
        let sub = |s: &mut Self, n: &sv_lang::SemNode<'_>| -> Option<Operand> {
            if let Some(a) = n.as_assertion_expr() {
                s.prop_expr(a, trees, scope)
            } else {
                n.as_expression()
                    .and_then(|x| s.leaf_operand(&x, trees, scope))
            }
        };
        let text = Self::assertion_text(trees, &e);
        let range_ops = |s: &mut Self, lo: u32, hi: Option<u32>| -> Vec<Operand> {
            let mut v = vec![s.bound(Some(lo))];
            if hi != Some(lo) {
                v.push(s.bound(hi));
            }
            v
        };
        let tr = vj_codegen::sva_shape::trees::Trees::new(trees);
        match e.kind() {
            A::Simple => {
                let leaf = sub(self, kids.first()?)?;
                let ranges = vj_codegen::sva_shape::ranges::sequence_range_of(e, tr, scope)
                    .unwrap_or_default();
                match ranges.first() {
                    None => Some(leaf),
                    Some(r) => {
                        let name = if text.contains("[->") {
                            "vpiGotoRepeatOp"
                        } else if text.contains("[=") {
                            "vpiRepeatOp"
                        } else {
                            "vpiConsecutiveRepeatOp"
                        };
                        let mut ops = vec![leaf];
                        ops.extend(range_ops(self, r.min, r.max));
                        Some(self.op_node(name, ops, false))
                    }
                }
            }
            A::SequenceConcat
                if kids.iter().any(|k| {
                    k.as_assertion_expr()
                        .is_some_and(|a| a.kind() == A::Clocking)
                }) =>
            {
                let mut seqs = Vec::new();
                for k in &kids {
                    let clocked = k
                        .as_assertion_expr()
                        .is_some_and(|a| a.kind() == A::Clocking);
                    let s = sub(self, k)?;
                    seqs.push(match self.ctx_clock {
                        Some(clock) if !clocked => {
                            Operand::Expr(self.model.add_expr(ExprNode::Clocked {
                                clock,
                                body: s,
                                seq: true,
                            }))
                        }
                        _ => s,
                    });
                }
                Some(Operand::Expr(
                    self.model.add_expr(ExprNode::MulticlockSeq { seqs }),
                ))
            }
            A::SequenceConcat => {
                use vj_codegen::sva_shape::ranges::{SequenceRangeValue, sequence_range_of};
                let seqs: Vec<Operand> = kids.iter().filter_map(|k| sub(self, k)).collect();
                let ranges = sequence_range_of(e, tr, scope).ok()?;
                // One range per `##`: the first operand has none unless the
                // chain opens with `##` (a unary cycle delay, 37.54).
                let leading = ranges.len() == seqs.len();
                if !leading && ranges.len() + 1 != seqs.len() {
                    return Some(Operand::Expr(self.model.add_expr(ExprNode::Unsupported(
                        "a sequence concatenation whose delays do not match its operands".into(),
                    ))));
                }
                let mut ranges = ranges.into_iter();
                let mut seqs = seqs.into_iter();
                let first = seqs.next()?;
                let mut acc = if leading {
                    let SequenceRangeValue { min, max } = ranges.next()?;
                    let mut ops = vec![first];
                    ops.extend(range_ops(self, min, max));
                    self.op_node("vpiUnaryCycleDelayOp", ops, false)
                } else {
                    first
                };
                for (s, SequenceRangeValue { min, max }) in seqs.zip(ranges) {
                    let mut ops = vec![acc, s];
                    ops.extend(range_ops(self, min, max));
                    acc = self.op_node("vpiCycleDelayOp", ops, false);
                }
                Some(acc)
            }
            A::SequenceWithMatch => self.sequence_with_match(e, kids, trees, scope),
            A::FirstMatch => {
                let s = kids
                    .iter()
                    .find_map(|k| k.as_assertion_expr())
                    .and_then(|a| self.prop_expr(a, trees, scope))?;
                Some(self.op_node("vpiFirstMatchOp", vec![s], false))
            }
            A::Unary | A::Binary => {
                let op = Op::of(e, scope).ok()?;
                let operands: Vec<Operand> = kids.iter().filter_map(|k| sub(self, k)).collect();
                let (name, strong, kw) = match op {
                    Op::Unary(U::Not) => ("vpiNotOp", false, None),
                    Op::Unary(U::NextTime) => ("vpiNexttimeOp", false, Some("nexttime")),
                    Op::Unary(U::SNextTime) => ("vpiNexttimeOp", true, Some("s_nexttime")),
                    Op::Unary(U::Always) => ("vpiAlwaysOp", false, Some("always")),
                    Op::Unary(U::SAlways) => ("vpiAlwaysOp", true, Some("s_always")),
                    Op::Unary(U::Eventually) => ("vpiEventuallyOp", false, Some("eventually")),
                    Op::Unary(U::SEventually) => ("vpiEventuallyOp", true, Some("s_eventually")),
                    Op::Binary(B::And) => ("vpiCompAndOp", false, None),
                    Op::Binary(B::Or) => ("vpiCompOrOp", false, None),
                    Op::Binary(B::Intersect) => ("vpiIntersectOp", false, None),
                    Op::Binary(B::Throughout) => ("vpiThroughoutOp", false, None),
                    Op::Binary(B::Within) => ("vpiWithinOp", false, None),
                    Op::Binary(B::Iff) => ("vpiIffOp", false, None),
                    Op::Binary(B::Until) => ("vpiUntilOp", false, None),
                    Op::Binary(B::SUntil) => ("vpiUntilOp", true, None),
                    Op::Binary(B::UntilWith) => ("vpiUntilWithOp", false, None),
                    Op::Binary(B::SUntilWith) => ("vpiUntilWithOp", true, None),
                    Op::Binary(B::Implies) => ("vpiImpliesOp", false, None),
                    Op::Binary(B::OverlappedImplication) => ("vpiOverlapImplyOp", false, None),
                    Op::Binary(B::NonOverlappedImplication) => {
                        ("vpiNonOverlapImplyOp", false, None)
                    }
                    Op::Binary(B::OverlappedFollowedBy) => ("vpiOverlapFollowedByOp", false, None),
                    Op::Binary(B::NonOverlappedFollowedBy) => {
                        ("vpiNonOverlapFollowedByOp", false, None)
                    }
                };
                let mut operands = operands;
                // 37.52 detail 2: nexttime's count only when not 1; always and
                // eventually their range.
                if let Some(kw) = kw
                    && let Some((lo, hi, ranged)) = Self::keyword_range(&text, kw)
                {
                    if name == "vpiNexttimeOp" {
                        if lo != 1 {
                            operands.push(self.bound(Some(lo)));
                        }
                    } else if ranged {
                        operands.push(self.bound(Some(lo)));
                        operands.push(self.bound(hi));
                    }
                }
                Some(self.op_node(name, operands, strong))
            }
            A::Clocking => {
                let c = vj_codegen::sva_shape::op::clocking_children(e, scope).ok()?;
                let clock = c
                    .event
                    .as_timing_control()
                    .and_then(|t| self.event_operand(&t))?;
                let seq = !matches!(
                    c.body.kind(),
                    A::Unary | A::Binary | A::Abort | A::Conditional | A::Case | A::DisableIff
                );
                let saved = self.ctx_clock.replace(clock);
                let body = self.prop_expr(c.body, trees, scope);
                self.ctx_clock = saved;
                let body = body?;
                Some(Operand::Expr(self.model.add_expr(ExprNode::Clocked {
                    clock,
                    body,
                    seq,
                })))
            }
            A::StrongWeak => {
                let inner = kids
                    .iter()
                    .find_map(|k| k.as_assertion_expr())
                    .and_then(|a| self.prop_expr(a, trees, scope))?;
                if text.trim_start().starts_with("strong")
                    && let Operand::Expr(x) = inner
                    && let Some(ExprNode::Op { meta, .. }) = self.model.expr_mut(x)
                {
                    meta.strong = true;
                }
                Some(inner)
            }
            A::Abort => {
                let a = vj_codegen::sva_shape::op::abort_children(e, scope).ok()?;
                let t = text.trim_start();
                let name = if t.starts_with("sync_accept_on") {
                    "vpiSyncAcceptOnOp"
                } else if t.starts_with("sync_reject_on") {
                    "vpiSyncRejectOnOp"
                } else if t.starts_with("accept_on") {
                    "vpiAcceptOnOp"
                } else {
                    "vpiRejectOnOp"
                };
                let cond = a.condition.as_expression().and_then(|x| self.operand(&x))?;
                let body = self.prop_expr(a.body, trees, scope)?;
                Some(self.op_node(name, vec![cond, body], false))
            }
            A::Conditional => {
                let ops: Vec<Operand> = kids.iter().filter_map(|k| sub(self, k)).collect();
                let name = if ops.len() > 2 {
                    "vpiIfElseOp"
                } else {
                    "vpiIfOp"
                };
                Some(self.op_node(name, ops, false))
            }
            A::DisableIff => {
                let d = vj_codegen::sva_shape::op::disable_iff_children(e, scope).ok()?;
                self.prop_expr(d.body, trees, scope)
            }
            A::Case => {
                let c = vj_codegen::sva_shape::op::case_children(e, tr, scope).ok()?;
                let cond = c.selector.as_expression().and_then(|x| self.operand(&x))?;
                let mut items = Vec::new();
                for item in c.items {
                    let exprs: Vec<Operand> = item
                        .labels
                        .iter()
                        .filter_map(|l| l.as_expression().and_then(|x| self.operand(&x)))
                        .collect();
                    let prop = self.prop_expr(item.body, trees, scope)?;
                    items.push(Operand::Expr(
                        self.model.add_expr(ExprNode::CasePropItem { exprs, prop }),
                    ));
                }
                if let Some(d) = c.default {
                    let prop = self.prop_expr(d, trees, scope)?;
                    items.push(Operand::Expr(self.model.add_expr(ExprNode::CasePropItem {
                        exprs: Vec::new(),
                        prop,
                    })));
                }
                Some(Operand::Expr(
                    self.model.add_expr(ExprNode::CaseProperty { cond, items }),
                ))
            }
            other => Some(Operand::Expr(self.model.add_expr(ExprNode::Unsupported(
                format!("a {other:?} property expression"),
            )))),
        }
    }

    /// A Boolean leaf of a property: an expression, or a named sequence or
    /// property instance (37.51, 37.54).
    fn leaf_operand(
        &mut self,
        x: &sv_lang::Expression<'_>,
        trees: &[SyntaxTree],
        scope: &Symbol<'_>,
    ) -> Option<Operand> {
        if x.kind() != sv_lang::kinds::ExpressionKind::AssertionInstance {
            let op = self.operand(x)?;
            if let Some(a) = self.cur_assertion {
                let r = x.source_range();
                if let Some(p) = self.model.props_mut(a) {
                    p.expr_srcs
                        .push(((r.start.buffer, r.start.offset, r.end.offset), op));
                }
            }
            return Some(op);
        }
        let bound = x.assertion_arguments();
        // slang exposes no declaration of an instance; a formal's parent is
        // it, and an instance without arguments is found by its name.
        let text = trees
            .iter()
            .find_map(|t| x.syntax(t).map(|n| n.text()))
            .unwrap_or_default();
        let name = text
            .split(|c: char| c == '(' || c.is_whitespace())
            .find(|w| !w.is_empty())
            .unwrap_or("")
            .rsplit(['.', ':'])
            .next()
            .unwrap_or("")
            .to_owned();
        let decl_sym = bound.first().and_then(|a| a.port.parent()).or_else(|| {
            let mut at = Some(*scope);
            while let Some(sc) = at {
                if let Some(m) = sc.members().find(|m| {
                    matches!(m.kind(), SymbolKind::Property | SymbolKind::Sequence)
                        && m.name() == name
                }) {
                    return Some(m);
                }
                at = sc.parent();
            }
            None
        });
        let property = decl_sym.is_some_and(|s| s.kind() == SymbolKind::Property);
        let decl = decl_sym.and_then(|s| self.model.find(&s.hierarchical_path()));
        let mut args = Vec::new();
        for a in bound {
            let op = if let Some(p) = a.actual.as_assertion_expr() {
                self.prop_expr(p, trees, scope)
            } else if let Some(e) = a.actual.as_expression() {
                self.leaf_operand(&e, trees, scope)
            } else if let Some(t) = a.actual.as_timing_control() {
                self.event_operand(&t)
            } else {
                None
            };
            args.push(op.unwrap_or_else(|| {
                Operand::Expr(self.model.add_expr(ExprNode::Unsupported(format!(
                    "a {} argument of a sequence/property instance",
                    a.actual.kind_name()
                ))))
            }));
        }
        Some(Operand::Expr(self.model.add_expr(ExprNode::AssertInst {
            decl,
            name,
            args,
            property,
        })))
    }

    /// 37.58: marks the parameters and specparams `e` names as folded when
    /// its operand `op` is missing or unrepresented, so their `vpiUse` is
    /// refused by name instead of listed incompletely.
    fn fold_if_unmodelled(&mut self, e: &sv_lang::Expression<'_>, op: Option<Operand>) {
        let ok = match op {
            None => false,
            Some(Operand::Expr(x)) => !matches!(self.model.expr(x), Some(ExprNode::Unsupported(_))),
            Some(Operand::Obj(_)) => true,
        };
        if ok {
            return;
        }
        let mut named = Vec::new();
        Self::named_parameters(e, &mut named);
        for p in named {
            if let Some(id) = self.prop_by_uid.get(&p).copied() {
                self.model.mark_param_folded(id);
            }
        }
    }

    /// A `specparam` with its value (37.28).
    fn spec_param(&mut self, sym: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        let name = sym.name().to_owned();
        let full = format!("{parent_name}.{name}");
        let mut obj = Obj::new(ObjKind::SpecParam, Some(parent), &name, &full);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(sym);
        Self::fill_value(&mut obj.props, &sym.constant_value());
        let id = self.add(obj);
        self.prop_by_uid.insert(sym.uid(), id);
        // 37.58: a specparam named in a specify block (path delay, timing
        // check limit) is refused by name; one named in another specparam's
        // initialiser is bound below.
        if self.param_has_folded_use(sym) {
            self.model.mark_param_folded(id);
        }
        self.typespec_rel(id, sym.declared_type());
        // `vpiExpr` (37.28): a spec param's value expression. Its syntax is
        // not reachable (`parameter_default_syntax` is for parameters), so
        // the evaluated constant stands in; a non-integral value gets none.
        let value = self.model.get(id).and_then(|o| match &o.props.param {
            Some(ParamValue::Logic(l, signed)) => Some(ExprNode::Const {
                value: l.clone(),
                signed: *signed,
                const_type: consts::VPI_BINARY_CONST,
            }),
            _ => None,
        });
        // 37.58: an initialiser that names parameters or specparams is
        // bound in the specparam's scope so those names have a `vpiUse`
        // (the folded constant would hide them).
        if let Some(op) = self.spec_param_initialiser(sym) {
            self.rel(id, consts::VPI_EXPR, op);
        } else if let Some(n) = value {
            let e = self.model.add_expr(n);
            self.rel(id, consts::VPI_EXPR, Operand::Expr(e));
        }
    }

    /// The bound initialiser of specparam `sym` when it names a parameter or
    /// a specparam (read from the declarator's `= expr`); a named one that
    /// cannot be bound is marked folded, so its uses are refused by name.
    fn spec_param_initialiser(&mut self, sym: &Symbol<'_>) -> Option<Operand> {
        let scope = sym.parent()?;
        for tree in self.locator.syntax_trees() {
            let Some(decl) = sym.syntax(&tree) else {
                continue;
            };
            // The declarator is `NAME = expr`: its only child node is the
            // initialiser expression.
            let init = decl.children().last();
            let expr = init?;
            let e = self
                .eval
                .bind_expression(expr, scope)
                .map(unwrap_invalid_expr);
            let mut named = Vec::new();
            if let Some(e) = e.as_ref().filter(|e| !e.is_bad()) {
                Self::named_parameters(e, &mut named);
            } else {
                // Unbindable: every parameter the text names is folded.
                let mut idents = Vec::new();
                expr.visit(|n| {
                    if n.kind() == sv_lang::kinds::SyntaxKind::IdentifierName {
                        idents.push(n.text().trim().to_owned());
                    }
                    sv_lang::Walk::Continue
                });
                for name in idents {
                    if let Some(p) = scope.find(&name)
                        && let Some(id) = self.prop_by_uid.get(&p.uid()).copied()
                    {
                        self.model.mark_param_folded(id);
                    }
                }
                return None;
            }
            if named.is_empty() {
                return None;
            }
            let op = e.as_ref().and_then(|e| self.operand(e));
            let modelled = op.is_some_and(|o| match o {
                Operand::Expr(x) => matches!(self.model.expr(x), Some(ExprNode::Op { .. })),
                Operand::Obj(p) => self
                    .model
                    .get(p)
                    .is_some_and(|o| matches!(o.kind, ObjKind::Parameter | ObjKind::SpecParam)),
            });
            if modelled {
                return op;
            }
            for p in named {
                if let Some(id) = self.prop_by_uid.get(&p).copied() {
                    self.model.mark_param_folded(id);
                }
            }
            return None;
        }
        None
    }

    /// Records `ty`'s typespec as `id`'s `vpiTypespec`.
    fn typespec_rel(&mut self, id: ObjId, ty: Option<Type<'_>>) {
        if let Some(ts) = ty.and_then(|t| self.typespec(&t)) {
            self.rel(id, header("vpiTypespec"), Operand::Obj(ts));
        }
    }

    /// The `vpiType` of the typespec of the (canonical) type `ty`.
    fn typespec_type(ty: &Type<'_>) -> i32 {
        let name = if ty.is_sequence_type() {
            "vpiSequenceTypespec"
        } else if ty.is_property_type() {
            "vpiPropertyTypespec"
        } else if ty.is_unpacked_array() || ty.is_dynamically_sized_array() {
            "vpiArrayTypespec"
        } else if ty.is_floating() {
            match ty.floating_kind() {
                FloatKind::ShortReal => "vpiShortRealTypespec",
                FloatKind::Real | FloatKind::RealTime => "vpiRealTypespec",
            }
        } else if ty.is_string() {
            "vpiStringTypespec"
        } else if ty.is_chandle() {
            "vpiChandleTypespec"
        } else if ty.is_event() {
            "vpiEventTypespec"
        } else if ty.is_void() {
            "vpiVoidTypespec"
        } else if ty.is_enum() {
            "vpiEnumTypespec"
        } else if ty.is_struct() {
            "vpiStructTypespec"
        } else if ty.is_union() {
            "vpiUnionTypespec"
        } else if ty.is_predefined_integer() {
            match ty.predefined_integer_kind() {
                PredefinedIntegerKind::ShortInt => "vpiShortIntTypespec",
                PredefinedIntegerKind::Int => "vpiIntTypespec",
                PredefinedIntegerKind::LongInt => "vpiLongIntTypespec",
                PredefinedIntegerKind::Byte => "vpiByteTypespec",
                PredefinedIntegerKind::Integer => "vpiIntegerTypespec",
                PredefinedIntegerKind::Time => "vpiTimeTypespec",
            }
        } else if Self::packed_array_of_aggregates(ty) {
            "vpiPackedArrayTypespec"
        } else if ty.is_four_state() {
            "vpiLogicTypespec"
        } else {
            "vpiBitTypespec"
        };
        header(name)
    }

    /// Whether `ty` is a built-in type a typedef can alias (37.25 detail 6:
    /// `typedef time my_time` aliases `time`), as opposed to a type the
    /// typedef itself defines (an enum, struct, union or array).
    fn is_builtin(ty: &Type<'_>) -> bool {
        let c = ty.canonical();
        !(c.is_enum()
            || c.is_struct()
            || c.is_union()
            || c.is_unpacked_array()
            || c.is_dynamically_sized_array()
            || c.is_packed_array())
    }

    /// The ranges of `ty`'s outermost run of fixed unpacked dimensions, or
    /// of its packed dimensions (not a packed struct's or enum's own range),
    /// leftmost first.
    fn dims_of(ty: &Type<'_>) -> Vec<(i32, i32)> {
        let mut out = Vec::new();
        let mut t = ty.canonical();
        if t.is_unpacked_array() {
            while t.is_unpacked_array() && !t.is_dynamically_sized_array() {
                let r = t.fixed_range();
                out.push((r.left, r.right));
                match t.element_type() {
                    Some(e) => t = e.canonical(),
                    None => break,
                }
            }
            return out;
        }
        while t.is_packed_array() {
            let r = t.fixed_range();
            out.push((r.left, r.right));
            match t.element_type() {
                Some(e) => t = e.canonical(),
                None => break,
            }
        }
        out
    }

    /// The typespec object (37.25) of `ty`, interned: a typedef by its
    /// declaring symbol, any other type by its printed form. `None` for a
    /// class or virtual interface type (the classes track's).
    fn typespec(&mut self, ty: &Type<'_>) -> Option<ObjId> {
        let alias = ty.is_alias();
        let key = if alias {
            format!("alias:{:?}", ty.as_symbol().uid())
        } else {
            format!("type:{}", ty.to_sv_string())
        };
        if let Some(&id) = self.typespecs.get(&key) {
            return Some(id);
        }
        let canon = ty.canonical();
        if canon.is_class() {
            return self.class_typespec(&canon, &key);
        }
        if canon.is_virtual_interface() {
            // An interface typespec (37.25): its interface's name and
            // whether it names a modport.
            let shape = vif_shape(&canon)?;
            let name = if alias {
                ty.as_symbol().name().to_owned()
            } else {
                String::new()
            };
            // The interface typespec of the interface itself (37.30 details
            // 1-3): it carries the parameter assignments; a modport's
            // typespec is its child, named by the modport identifier.
            let iface_key = format!(
                "iface:{}#{}",
                shape.def,
                shape
                    .params
                    .iter()
                    .map(|(n, v)| format!("{n}={v}"))
                    .collect::<Vec<_>>()
                    .join(",")
            );
            let iface = match self.typespecs.get(&iface_key) {
                Some(&i) => i,
                None => {
                    let mut o = Obj::new(ObjKind::Typespec, None, "", "");
                    o.props.stmt_type = header("vpiInterfaceTypespec");
                    o.props.def_name = Some(shape.def.clone());
                    let i = self.add(o);
                    for (pn, pv) in &shape.params {
                        self.interface_param_assign(i, pn, pv);
                    }
                    self.typespecs.insert(iface_key, i);
                    i
                }
            };
            let id = if let Some(m) = &shape.modport {
                let mut obj = Obj::new(ObjKind::Typespec, Some(iface), &name, "");
                obj.props.stmt_type = header("vpiInterfaceTypespec");
                obj.props.def_name = Some(m.clone());
                obj.props.is_modport = true;
                self.add(obj)
            } else if alias {
                // A typedef names the interface typespec: its own object,
                // sharing the parameter assignments.
                let mut obj = Obj::new(ObjKind::Typespec, None, &name, "");
                obj.props.stmt_type = header("vpiInterfaceTypespec");
                obj.props.def_name = Some(shape.def.clone());
                let i = self.add(obj);
                for (pn, pv) in &shape.params {
                    self.interface_param_assign(i, pn, pv);
                }
                i
            } else {
                iface
            };
            self.typespecs.insert(key, id);
            return Some(id);
        }
        if canon.is_error() {
            return None;
        }
        let name = if alias {
            ty.as_symbol().name().to_owned()
        } else {
            String::new()
        };
        // The type this typedef chain finally defines (an alias of an alias
        // shares its structure).
        let mut shape = *ty;
        let mut target = None;
        while shape.is_alias() {
            let Some(next) = shape.as_symbol().declared_type() else {
                break;
            };
            if target.is_none() {
                target = Some(next);
            }
            shape = next;
        }
        let mut obj = Obj::new(ObjKind::Typespec, None, &name, "");
        obj.props.stmt_type = Self::typespec_type(&canon);
        obj.props.signed = canon.is_signed();
        obj.props.vector =
            canon.is_packed_array() || (canon.is_integral() && canon.bit_width() > 1);
        obj.props.packed = (canon.is_struct() && !canon.is_unpacked_struct())
            || canon.is_packed_union()
            || Self::packed_array_of_aggregates(&canon);
        obj.props.tagged = (canon.is_packed_union() && canon.packed_union_is_tagged())
            || (canon.is_unpacked_union() && canon.unpacked_union_is_tagged());
        obj.props.soft = canon.is_packed_union() && canon.packed_union_is_soft();
        obj.props.dims = Self::dims_of(&canon);
        obj.props.range = obj.props.dims.first().copied();
        if canon.is_unpacked_array() || canon.is_dynamically_sized_array() {
            obj.props.array_type = header(if canon.is_associative_array() {
                "vpiAssocArray"
            } else if canon.is_queue() {
                "vpiQueueArray"
            } else if canon.is_dynamically_sized_array() {
                "vpiDynamicArray"
            } else {
                "vpiStaticArray"
            });
        }
        obj.props.file = Some(self.file.clone());
        if alias {
            obj.props.line = self.locator.line(&ty.as_symbol());
        }
        let id = self.add(obj);
        self.typespecs.insert(key, id);
        // A typedef of a typedef or of a built-in type aliases it (37.25
        // details 1 and 6).
        if let Some(t) = target
            && (t.is_alias() || Self::is_builtin(&t))
            && let Some(ts) = self.typespec(&t)
        {
            self.rel(id, header("vpiTypedefAlias"), Operand::Obj(ts));
        }
        let shape_c = shape.canonical();
        // One dimension unwound (detail 8): an array's element type, a
        // packed vector's with its leftmost range removed.
        let unwinds = shape_c.is_unpacked_array()
            || shape_c.is_dynamically_sized_array()
            || shape_c.is_packed_array();
        if unwinds
            && let Some(e) = shape.element_type()
            && let Some(ts) = self.typespec(&e)
        {
            self.rel(id, header("vpiElemTypespec"), Operand::Obj(ts));
        }
        if canon.is_associative_array()
            && let Some(k) = canon.associative_index_type()
            && let Some(ts) = self.typespec(&k)
        {
            self.rel(id, header("vpiIndexTypespec"), Operand::Obj(ts));
        }
        if canon.is_enum() {
            if let Some(b) = canon.enum_base()
                && let Some(ts) = self.typespec(&b)
            {
                self.rel(id, header("vpiBaseTypespec"), Operand::Obj(ts));
            }
            for m in canon.enum_members() {
                let mname = m.name().to_owned();
                let mut c = Obj::new(ObjKind::EnumConst, Some(id), &mname, "");
                Self::fill_value(&mut c.props, &m.constant_value());
                c.props.file = Some(self.file.clone());
                c.props.line = self.locator.line(&m);
                self.add(c);
            }
        }
        if canon.is_struct() || canon.is_union() {
            for f in canon.fields() {
                let fname = f.name().to_owned();
                let mut m = Obj::new(ObjKind::TypespecMember, Some(id), &fname, "");
                m.props.file = Some(self.file.clone());
                m.props.line = self.locator.line(&f);
                // vpiRandType (37.25): `rand`/`randc` on the member.
                m.props.rand_type = match f.field_rand_mode() {
                    sv_lang::RandMode::None => 0,
                    sv_lang::RandMode::Rand => header("vpiRand"),
                    sv_lang::RandMode::RandC => header("vpiRandC"),
                };
                let mid = self.add(m);
                // The explicit default member value of an unpacked
                // structure member (37.25 detail 7).
                if let Some(init) = f.initializer()
                    && let Some(op) = self.operand(&init)
                {
                    self.rel(mid, consts::VPI_EXPR, op);
                }
                self.typespec_rel(mid, f.value_type());
            }
        }
        Some(id)
    }

    /// A constant's value as a parameter or attribute value, with its width
    /// and signedness.
    fn fill_value(props: &mut Props, cv: &Option<sv_lang::ConstantValue>) {
        let obj = props;
        obj.param = match cv {
            Some(c) if c.as_integer().is_some() => {
                let i = c.as_integer().expect("checked");
                let width = i.bit_width();
                let mut l = Logic::zero(width);
                for k in 0..width {
                    let b = i.bit(k as usize).map_or(B4::Zero, |b| {
                        if b.is_unknown() {
                            if b.logic_t_value() == sv_lang::Bit::z().logic_t_value() {
                                B4::Z
                            } else {
                                B4::X
                            }
                        } else if b.logic_t_value() == 1 {
                            B4::One
                        } else {
                            B4::Zero
                        }
                    });
                    l.set(k, b);
                }
                obj.width = width as i32;
                obj.signed = i.is_signed();
                obj.vector = width > 1;
                Some(ParamValue::Logic(l, i.is_signed()))
            }
            Some(c) if c.as_f64().is_some() => {
                obj.width = 64;
                Some(ParamValue::Real(c.as_f64().expect("checked")))
            }
            Some(c) if c.as_str().is_some() => {
                let s = c.as_str().expect("checked").to_owned();
                obj.width = 8 * s.len() as i32;
                Some(ParamValue::Str(s))
            }
            _ => None,
        };
    }

    /// The generate scopes, instances, arrays and modports declared directly
    /// in `scope`, as children of `parent`.
    fn members(
        &mut self,
        scope: &Symbol<'_>,
        parent: ObjId,
        parent_name: &str,
    ) -> Result<(), VpiError> {
        for m in scope.members() {
            match m.kind() {
                SymbolKind::Instance => {
                    let name = m.name().to_owned();
                    let full = format!("{parent_name}.{name}");
                    self.instance(&m, Some(parent), &name, &full, None, false)?;
                }
                SymbolKind::InstanceArray if is_primitive_array(&m) => {
                    let name = m.name().to_owned();
                    self.primitive_array(&m, parent, parent_name, &name);
                }
                SymbolKind::InstanceArray => {
                    let name = m.name().to_owned();
                    self.instance_array(&m, parent, parent_name, &name, None)?;
                }
                SymbolKind::GenerateBlock => {
                    if !m.generate_block_is_uninstantiated() {
                        let name = m.generate_block_external_name().unwrap_or_default();
                        self.gen_scope(&m, parent, parent_name, &name, None)?;
                    }
                }
                SymbolKind::GenerateBlockArray => {
                    self.gen_scope_array(&m, parent, parent_name)?;
                }
                SymbolKind::Modport => {
                    let name = m.name().to_owned();
                    let full = format!("{parent_name}.{name}");
                    let mut obj = Obj::new(ObjKind::Modport, Some(parent), &name, &full);
                    obj.props.file = Some(self.file.clone());
                    obj.props.line = self.locator.line(&m);
                    let mp_id = self.add(obj);
                    // The modport's `vpiIODecl`s (37.7/37.13): one per port
                    // specifier, its `vpiExpr` the interface's net or variable.
                    for port in m.members() {
                        // An `import`/`export` item (37.7/37.13): an io decl
                        // named for the task or function, undefined direction
                        // and size, whose `vpiExpr` is the interface tf decl
                        // (37.8) when the interface declares one (an
                        // `extern` prototype). 37.13 names no other target,
                        // so an import of a plain interface task has none.
                        if port.kind() == SymbolKind::MethodPrototype {
                            let pname = port.name().to_owned();
                            let pfull = format!("{full}.{pname}");
                            let mut io = Obj::new(ObjKind::IODecl, Some(mp_id), &pname, &pfull);
                            io.props.direction = consts::VPI_UNDEFINED;
                            io.props.file = Some(self.file.clone());
                            io.props.line = self.locator.line(&port);
                            let io_id = self.add(io);
                            self.itf_tf_links.push((
                                mp_id,
                                io_id,
                                format!("{parent_name}.{pname}"),
                            ));
                            continue;
                        }
                        if port.kind() != SymbolKind::ModportPort {
                            continue;
                        }
                        let pname = port.name().to_owned();
                        let pfull = format!("{full}.{pname}");
                        let mut io = Obj::new(ObjKind::IODecl, Some(mp_id), &pname, &pfull);
                        io.props.direction = match port.modport_port_direction() {
                            ArgumentDirection::In => consts::VPI_INPUT,
                            ArgumentDirection::Out => consts::VPI_OUTPUT,
                            ArgumentDirection::InOut => consts::VPI_INOUT,
                            ArgumentDirection::Ref => consts::VPI_REF,
                        };
                        let internal = port.modport_port_internal_symbol();
                        if let Some(ty) = internal.as_ref().and_then(|s| s.value_type()) {
                            io.props.width = ty.bit_width() as i32;
                            io.props.signed = ty.is_signed();
                        }
                        io.props.file = Some(self.file.clone());
                        io.props.line = self.locator.line(&port);
                        let io_id = self.add(io);
                        if internal.is_some() {
                            self.path_links.push((
                                io_id,
                                consts::VPI_EXPR,
                                format!("{parent_name}.{pname}"),
                            ));
                        }
                    }
                }
                SymbolKind::Variable => self.data(&m, parent, parent_name, false),
                SymbolKind::Net => {
                    self.data(&m, parent, parent_name, true);
                    if let Some(init) = m.initializer() {
                        self.net_decl_assign(&m, &init, parent, parent_name);
                    }
                }
                SymbolKind::Parameter => self.parameter(&m, parent, parent_name),
                // A class declaration (37.12 `vpiClassDefn`); a generic
                // class's contents come from a specialization.
                SymbolKind::ClassType => {
                    self.class_defn(&m, Some(&m), Some((parent, parent_name)));
                }
                SymbolKind::GenericClassDef => {
                    self.class_defn(&m, None, Some((parent, parent_name)));
                }
                // A typedef: the scope's `vpiTypedef` (37.12).
                SymbolKind::TypeAlias => {
                    if let Some(ts) = m.as_type().and_then(|t| self.typespec(&t)) {
                        self.rel(parent, header("vpiTypedef"), Operand::Obj(ts));
                    }
                }
                SymbolKind::ProceduralBlock => {
                    self.assertions(&m, parent, parent_name);
                    // A module-level assertion is hosted by a procedure slang
                    // synthesizes; it is the assertion object, not a process.
                    if vj_codegen::module::static_concurrent_assertion_of(&m).is_none()
                        && vj_codegen::module::static_deferred_assertion_of(&m).is_none()
                    {
                        self.process(&m, parent, parent_name);
                    }
                }
                SymbolKind::Subroutine => self.task_func(&m, parent, parent_name, "."),
                // An interface's `extern` prototype (37.8).
                SymbolKind::MethodPrototype
                    if vj_sim::netlist::itf::extern_prototype(&m).is_some() =>
                {
                    self.interface_tf_decl(&m, parent, parent_name);
                }
                SymbolKind::ClockingBlock => self.clocking(&m, parent, parent_name),
                SymbolKind::PrimitiveInstance => {
                    let name = m.name().to_owned();
                    let full = format!("{parent_name}.{name}");
                    self.primitive(&m, parent, &name, &full, None, &m, &m);
                }
                SymbolKind::ContinuousAssign => self.cont_assign(&m, parent),
                SymbolKind::LetDecl => self.let_decl(&m, parent, parent_name),
                SymbolKind::SpecifyBlock => {
                    // `vpiModPathHasIfNone` (37.39): the terminals of every
                    // `ifnone` path of the block.
                    let ifnone_ends: Vec<String> = m
                        .members()
                        .filter(|p| p.kind() == SymbolKind::TimingPath && self.is_ifnone(p))
                        .map(|p| self.path_ends(&p))
                        .collect();
                    for p in m.members() {
                        match p.kind() {
                            SymbolKind::TimingPath => {
                                let has =
                                    self.is_ifnone(&p) || ifnone_ends.contains(&self.path_ends(&p));
                                self.mod_path(&p, parent, has);
                            }
                            SymbolKind::SystemTimingCheck => self.tchk(&p, parent),
                            SymbolKind::Specparam => self.spec_param(&p, parent, parent_name),
                            _ => {}
                        }
                    }
                }
                SymbolKind::Specparam => self.spec_param(&m, parent, parent_name),
                SymbolKind::Property | SymbolKind::Sequence => {
                    self.assertion_decl(&m, parent, parent_name);
                }
                // `defparam a.b.P = v;` (37.28, 23.10.1).
                SymbolKind::DefParam => {
                    let mut o = Obj::new(ObjKind::DefParam, Some(parent), "", "");
                    o.props.file = Some(self.file.clone());
                    o.props.line = self.locator.line(&m);
                    let id = self.add(o);
                    // The resolved target parameter (23.10.1), not the
                    // written hierarchical name.
                    if let Some(t) = m.defparam_target() {
                        self.defparam_links.push((id, vec![t.hierarchical_path()]));
                    }
                }
                SymbolKind::NetType if !m.net_type_is_built_in() => {
                    self.nettype_decl(&m, parent, parent_name);
                }
                // `alias a = b = c;`: one alias statement per left-hand net,
                // the last net the right-hand side of all (37.76).
                SymbolKind::NetAlias => {
                    let nets: Vec<sv_lang::Expression<'_>> = m.net_alias_net_references().collect();
                    if let Some((rhs, lhss)) = nets.split_last() {
                        for lhs in lhss {
                            let mut o = Obj::new(ObjKind::AliasStmt, Some(parent), "", "");
                            o.props.file = Some(self.file.clone());
                            o.props.line = self.locator.line(&m);
                            let id = self.add(o);
                            if let Some(op) = self.operand(lhs) {
                                self.rel(id, consts::VPI_LHS, op);
                            }
                            if let Some(op) = self.operand(rhs) {
                                self.rel(id, consts::VPI_RHS, op);
                            }
                        }
                    }
                }
                SymbolKind::TypeParameter => {
                    let name = m.name().to_owned();
                    let full = format!("{parent_name}.{name}");
                    let mut obj = Obj::new(ObjKind::TypeParameter, Some(parent), &name, &full);
                    obj.props.local_param = m.parameter_is_local_param();
                    obj.props.file = Some(self.file.clone());
                    obj.props.line = self.locator.line(&m);
                    let id = self.add(obj);
                    self.typespec_rel(id, m.declared_type());
                    self.type_parameter_default(&m, id);
                }
                SymbolKind::Genvar => {
                    let name = m.name().to_owned();
                    let full = format!("{parent_name}.{name}");
                    let mut obj = Obj::new(ObjKind::GenVar, Some(parent), &name, &full);
                    obj.props.file = Some(self.file.clone());
                    obj.props.line = self.locator.line(&m);
                    self.add(obj);
                }
                // Processes, subroutines, typespecs... arrive with the tasks
                // that model their VPI classes.
                _ => {}
            }
        }
        // The `extern` method definitions this scope implements for the
        // interfaces its ports connect to (`task b.put(...)`, 25.7.3): slang
        // keeps them out of the member list.
        for imp in vj_sim::netlist::itf::extern_impls_in(scope) {
            self.task_func(&imp, parent, parent_name, ".");
        }
        Ok(())
    }

    /// An instance array (`name` is `u`, or `u[1]` for a nested dimension)
    /// and its elements.
    fn instance_array(
        &mut self,
        array: &Symbol<'_>,
        parent: ObjId,
        parent_name: &str,
        name: &str,
        index: Option<i32>,
    ) -> Result<(), VpiError> {
        let full = format!("{parent_name}.{name}");
        self.instance_array_at(array, parent, &full, name, index)
    }

    fn instance_array_at(
        &mut self,
        array: &Symbol<'_>,
        parent: ObjId,
        full: &str,
        name: &str,
        index: Option<i32>,
    ) -> Result<(), VpiError> {
        let range = array.instance_array_range();
        let elements: Vec<Symbol<'_>> = array.instance_array_elements().collect();
        let kind = match Self::array_kind(array) {
            Some(k) => k,
            None => ObjKind::ModuleArray,
        };
        let mut obj = Obj::new(kind, Some(parent), name, full);
        obj.props.index = index;
        obj.props.size = Some(elements.len() as i32);
        obj.props.range = Some((range.left, range.right));
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(array);
        let id = self.add(obj);
        for (i, element) in elements.iter().enumerate() {
            let idx = element_index(range, i);
            // Elements are named after the array's own (possibly indexed)
            // name: `grid[1]`, then `grid[1][2]`.
            let element_name = format!("{name}[{idx}]");
            let element_full = format!("{full}[{idx}]");
            match element.kind() {
                SymbolKind::InstanceArray => {
                    self.instance_array_at(element, id, &element_full, &element_name, Some(idx))?;
                }
                SymbolKind::Instance => {
                    self.instance(
                        element,
                        Some(id),
                        &element_name,
                        &element_full,
                        Some(idx),
                        false,
                    )?;
                }
                // Primitive and checker arrays arrive with T20/T24.
                _ => {}
            }
        }
        self.instance_array_expr(id);
        Ok(())
    }

    /// 37.11 detail 1: an instance array's `vpiExpr`, a `vpiListOp` of the
    /// connections written for it. They are the high conns of the first
    /// element's ports (a nested array: of its first leaf instance); an array
    /// whose ports are all unconnected has none.
    fn instance_array_expr(&mut self, array: ObjId) {
        let mut at = array;
        let first = loop {
            let Some(&c) = self
                .model
                .children_where(at, |k| k.is_instance() || k.is_instance_array())
                .first()
            else {
                return;
            };
            if self
                .model
                .get(c)
                .is_some_and(|o| o.kind.is_instance_array())
            {
                at = c;
            } else {
                break c;
            }
        };
        let ops: Vec<Operand> = self
            .model
            .children_of_kind(first, ObjKind::Port)
            .into_iter()
            .filter_map(|p| {
                self.model
                    .get(p)?
                    .props
                    .rels
                    .iter()
                    .find(|(k, _)| *k == consts::VPI_HIGH_CONN)
                    .map(|(_, o)| *o)
            })
            .collect();
        if ops.is_empty() {
            return;
        }
        let op = self.op_node("vpiListOp", ops, false);
        if let Some(p) = self.model.props_mut(array) {
            p.rels.push((consts::VPI_EXPR, op));
        }
    }

    /// The array kind (`vpiModuleArray`...) of the instances at the bottom of
    /// `array`.
    fn array_kind(array: &Symbol<'_>) -> Option<ObjKind> {
        for element in array.instance_array_elements() {
            match element.kind() {
                SymbolKind::Instance => {
                    return element
                        .instance_definition()
                        .map(|d| match Self::instance_kind(&d) {
                            ObjKind::Interface => ObjKind::InterfaceArray,
                            ObjKind::Program => ObjKind::ProgramArray,
                            _ => ObjKind::ModuleArray,
                        });
                }
                SymbolKind::InstanceArray => return Self::array_kind(&element),
                _ => {}
            }
        }
        None
    }

    /// One generate scope and what it contains. `index` is its loop index
    /// when it is one iteration of a loop generate.
    fn gen_scope(
        &mut self,
        block: &Symbol<'_>,
        parent: ObjId,
        parent_name: &str,
        name: &str,
        index: Option<i32>,
    ) -> Result<(), VpiError> {
        let full = format!("{parent_name}.{name}");
        let mut obj = Obj::new(ObjKind::GenScope, Some(parent), name, &full);
        obj.props.index = index;
        obj.props.implicit = index.is_none() && !self.has_block_name(block);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(block);
        let id = self.add(obj);
        self.members(block, id, &full)
    }

    /// Whether the generate block `block` is named in the source (`begin :
    /// name`); an unnamed one is an implicit declaration (37.85 detail 2).
    fn has_block_name(&self, block: &Symbol<'_>) -> bool {
        use sv_lang::kinds::SyntaxKind;
        self.locator.syntax_trees().iter().any(|t| {
            block.syntax(t).is_some_and(|n| {
                n.kind() == SyntaxKind::GenerateBlock
                    && n.children()
                        .any(|c| c.kind() == SyntaxKind::NamedBlockClause)
            })
        })
    }

    /// A loop generate: the array object and one scope per iteration.
    fn gen_scope_array(
        &mut self,
        array: &Symbol<'_>,
        parent: ObjId,
        parent_name: &str,
    ) -> Result<(), VpiError> {
        let name = array.generate_block_external_name().unwrap_or_default();
        let full = format!("{parent_name}.{name}");
        let entries: Vec<Symbol<'_>> = if array.generate_block_array_valid() {
            array.generate_block_array_entries().collect()
        } else {
            Vec::new()
        };
        let mut obj = Obj::new(ObjKind::GenScopeArray, Some(parent), &name, &full);
        obj.props.size = Some(entries.len() as i32);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(array);
        let id = self.add(obj);
        for (i, entry) in entries.iter().enumerate() {
            let idx = entry
                .generate_block_array_index()
                .and_then(|v| v.as_i64())
                .map_or(i as i32, |v| v as i32);
            let entry_name = format!("{name}[{idx}]");
            self.gen_scope(entry, id, &full_of(parent_name), &entry_name, Some(idx))?;
        }
        Ok(())
    }

    /// The assertions in procedural block `block` (a module-level concurrent
    /// assertion is a procedural block of its own), as children of `parent`.
    /// A labeled assertion (`a1: assert ...`) is a named block holding only
    /// that statement: it is named after the label; an assertion inside a
    /// named block is named under the block (`top.blk.a2`); an unlabeled one
    /// has no name (39.3.1).
    fn assertions(&mut self, block: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        let Some(body) = vj_sim::process::cfg::proc_body(block) else {
            return;
        };
        let mut stack = vec![(body.as_sem_node(), parent_name.to_owned(), None::<String>)];
        while let Some((node, prefix, label)) = stack.pop() {
            let Some(stmt) = node.as_statement() else {
                for c in vj_sim::process::cfg::live_children(&node).into_iter().rev() {
                    stack.push((c, prefix.clone(), None));
                }
                continue;
            };
            if stmt.kind() == StatementKind::ConcurrentAssertion
                && stmt.assertion_kind() == Some(AssertionKind::Expect)
            {
                // An expect statement (37.73): a statement, not an assertion,
                // with a property spec and pass/fail statements.
                let mut obj = Obj::new(ObjKind::Stmt, Some(parent), "", "");
                obj.props.stmt_type = header("vpiExpectStmt");
                obj.props.file = Some(self.file.clone());
                obj.props.line = self.locator.stmt_line(&stmt);
                let id = self.add(obj);
                self.assertion_ids
                    .insert(stmt.source_range().start.offset, id);
                self.attributes(stmt.attributes(), id, "", false);
                self.assertion_structure(&stmt, id, &prefix, block);
                continue;
            }
            if let Some((kind, deferred, final_)) = assertion_kind(&stmt) {
                let (name, full) = match label {
                    Some(n) => (n.clone(), format!("{prefix}.{n}")),
                    None => (String::new(), String::new()),
                };
                let mut obj = Obj::new(kind, Some(parent), &name, &full);
                obj.props.def_name = self.def_name.clone();
                obj.props.deferred = deferred;
                obj.props.final_ = final_;
                obj.props.file = Some(self.file.clone());
                obj.props.line = self.locator.stmt_line(&stmt);
                let id = self.add(obj);
                self.assertion_ids
                    .insert(stmt.source_range().start.offset, id);
                if let Some(p) = self.model.props_mut(id) {
                    p.src_offset = Some(stmt.source_range().start.offset);
                }
                self.attributes(stmt.attributes(), id, &full, false);
                self.assertion_structure(&stmt, id, &prefix, block);
                continue;
            }
            let children = node.children();
            let named = (stmt.kind() == StatementKind::Block)
                .then(|| stmt.block_symbol())
                .flatten()
                .map(|s| s.name().to_owned())
                .filter(|n| !n.is_empty());
            match named {
                Some(n) => {
                    let only_assertion = children.len() == 1
                        && children[0]
                            .as_statement()
                            .is_some_and(|c| assertion_kind(&c).is_some());
                    if only_assertion {
                        stack.push((children[0], prefix, Some(n)));
                    } else {
                        let inner = format!("{prefix}.{n}");
                        for c in children.into_iter().rev() {
                            stack.push((c, inner.clone(), None));
                        }
                    }
                }
                None => {
                    for c in children.into_iter().rev() {
                        stack.push((c, prefix.clone(), None));
                    }
                }
            }
        }
    }

    /// A clocking block and its clock variables (37.48).
    fn clocking(&mut self, block: &Symbol<'_>, parent: ObjId, parent_name: &str) {
        let name = block.name().to_owned();
        let full = format!("{parent_name}.{name}");
        let mut obj = Obj::new(ObjKind::ClockingBlock, Some(parent), &name, &full);
        let keyword = clocking_keyword(block, &self.locator.syntax_trees());
        obj.props.default_clocking = keyword == Some(sv_lang::kinds::TokenKind::DefaultKeyword);
        obj.props.global_clocking = keyword == Some(sv_lang::kinds::TokenKind::GlobalKeyword);
        let (din, dout) = (
            block.clocking_block_default_input_skew(),
            block.clocking_block_default_output_skew(),
        );
        obj.props.input_edge = edge_const(din.edge);
        obj.props.output_edge = edge_const(dout.edge);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(block);
        let line = obj.props.line;
        let id = self.add(obj);
        self.attributes(block.attributes(), id, &full, false);
        // 37.48: the default skews are delay controls, the clocking event an
        // event control.
        self.skew_rel(id, "vpiInputSkew", &din, line);
        self.skew_rel(id, "vpiOutputSkew", &dout, line);
        if let Some(tc) = block
            .clocking_block_event()
            .and_then(|n| n.as_timing_control())
            && let Some(ev) = self.timing_control_obj(&tc, id, line)
        {
            self.rel(id, header("vpiClockingEvent"), Operand::Obj(ev));
        }
        for v in block.members() {
            if v.kind() != SymbolKind::ClockVar {
                continue;
            }
            let vname = v.name().to_owned();
            let mut io = Obj::new(
                ObjKind::ClockingIODecl,
                Some(id),
                &vname,
                &format!("{full}.{vname}"),
            );
            io.props.direction = match v.clock_var_direction() {
                ArgumentDirection::In => consts::VPI_INPUT,
                ArgumentDirection::Out => consts::VPI_OUTPUT,
                ArgumentDirection::InOut => consts::VPI_INOUT,
                ArgumentDirection::Ref => consts::VPI_REF,
            };
            // An IO's own skew, else the block's default (14.3).
            let (vin, vout) = (v.clock_var_input_skew(), v.clock_var_output_skew());
            io.props.input_edge = edge_const(if vin.has_value() { vin.edge } else { din.edge });
            io.props.output_edge = edge_const(if vout.has_value() {
                vout.edge
            } else {
                dout.edge
            });
            io.props.file = Some(self.file.clone());
            let line = self.locator.line(&v);
            io.props.line = line;
            let io_id = self.add(io);
            // 37.48 detail 1: the IO's own skews, not the block's defaults.
            self.skew_rel(io_id, "vpiInputSkew", &vin, line);
            self.skew_rel(io_id, "vpiOutputSkew", &vout, line);
            // Detail 4: the expression the IO names (`input b = top.a`, else
            // the signal of the same name).
            if let Some(init) = v.initializer()
                && let Some(operand) = self.operand(&init)
            {
                self.rel(io_id, consts::VPI_EXPR, operand);
            }
        }
    }

    /// The `vpiInputSkew`/`vpiOutputSkew` delay control of a clocking block or
    /// IO declaration `id` (37.48): none when the skew has no delay.
    fn skew_rel(&mut self, id: ObjId, rel: &str, skew: &sv_lang::ClockingSkew<'_>, line: i32) {
        if let Some(tc) = skew.delay.and_then(|d| d.as_timing_control())
            && let Some(obj) = self.timing_control_obj(&tc, id, line)
        {
            self.rel(id, header(rel), Operand::Obj(obj));
        }
    }

    /// The signal a plainly named expression refers to, as a link key.
    fn link(&mut self, id: ObjId, side: u8, e: &sv_lang::Expression<'_>) {
        let plain = e.kind() == sv_lang::kinds::ExpressionKind::NamedValue;
        if let (true, Some(sym), Some(body)) = (plain, e.referenced_symbol(), self.body.clone()) {
            self.links.push((id, side, body, sym.uid()));
        }
    }

    /// A primitive's `[rise, fall, turn-off]` delays in ticks (28.16.2: one
    /// value gives all three, two give turn-off as the smaller of the two);
    /// `None` when a delay is not a constant.
    fn primitive_delays(&self, inst: &Symbol<'_>) -> Option<[u64; 3]> {
        let Some(d) = inst.primitive_instance_delay() else {
            return Some([0; 3]);
        };
        let tc = d.as_timing_control()?;
        let list = crate::primitives::delay_values_of(
            self.eval,
            tc.children().into_iter().filter_map(|n| n.as_expression()),
            inst,
        )
        .ok()?;
        match list[..] {
            [d] => Some([d, d, d]),
            [r, f] => Some([r, f, r.min(f)]),
            [r, f, z] => Some([r, f, z]),
            _ => None,
        }
    }

    /// A primitive instance's delay expression (one operand, or a list
    /// operation of several), bound in its scope.
    fn primitive_delay_operand(&mut self, inst: &Symbol<'_>) -> Option<Operand> {
        let tc = inst.primitive_instance_delay()?.as_timing_control()?;
        let exprs: Vec<sv_lang::Expression<'_>> = tc
            .children()
            .into_iter()
            .filter_map(|n| n.as_expression())
            .collect();
        let ops: Vec<Operand> = exprs.iter().filter_map(|e| self.operand(e)).collect();
        match ops[..] {
            [] => None,
            [one] => Some(one),
            _ => Some(self.op_node("vpiListOp", ops, false)),
        }
    }

    /// The delay of a continuous assignment or net declaration assignment
    /// (37.47): its `[rise, fall, turn-off]` ticks (as [`Self::primitive_delays`];
    /// all zero without a delay) and its `vpiDelay` expression.
    fn assign_delay(&mut self, delay: Option<sv_lang::SemNode<'_>>, scope: &Symbol<'_>, id: ObjId) {
        let Some(tc) = delay.and_then(|d| d.as_timing_control()) else {
            if let Some(p) = self.model.props_mut(id) {
                p.prim_delays = Some([0; 3]);
            }
            return;
        };
        let exprs: Vec<sv_lang::Expression<'_>> = tc
            .children()
            .into_iter()
            .filter_map(|n| n.as_expression())
            .collect();
        let list = crate::primitives::delay_values_of(self.eval, exprs.iter().copied(), scope).ok();
        let ticks = match list.as_deref() {
            Some([d]) => Some([*d, *d, *d]),
            Some([r, f]) => Some([*r, *f, (*r).min(*f)]),
            Some([r, f, z]) => Some([*r, *f, *z]),
            _ => None,
        };
        let ops: Vec<Operand> = exprs.iter().filter_map(|e| self.operand(e)).collect();
        let op = match ops[..] {
            [] => None,
            [one] => Some(one),
            _ => Some(self.op_node("vpiListOp", ops, false)),
        };
        if let Some(p) = self.model.props_mut(id) {
            p.prim_delays = ticks;
            p.delay_op = op;
        }
    }

    /// A primitive instance and its terminals (37.35). `at` is the symbol
    /// whose source line it reports (an array element's array).
    #[allow(clippy::too_many_arguments)]
    fn primitive(
        &mut self,
        inst: &Symbol<'_>,
        parent: ObjId,
        name: &str,
        full: &str,
        index: Option<i32>,
        at: &Symbol<'_>,
        conn_src: &Symbol<'_>,
    ) {
        let trees = self.locator.syntax_trees();
        let def = crate::primitives::type_name(inst, &trees).unwrap_or_default();
        let conns: Vec<sv_lang::Expression<'_>> =
            conn_src.primitive_instance_port_connections().collect();
        let (kind, prim_type, outs, inouts) = prim_class(&def, conns.len(), inst);
        let mut obj = Obj::new(kind, Some(parent), name, full);
        obj.props.def_name = Some(def.clone());
        obj.props.prim_type = prim_type;
        obj.props.size = Some(conns.len() as i32);
        obj.props.index = index;
        let given = inst.primitive_instance_drive_strength();
        let weak_default = def.starts_with('r') || def == "pullup" || def == "pulldown";
        obj.props.strength0 = strength_const(given.strength0, weak_default);
        obj.props.strength1 = strength_const(given.strength1, weak_default);
        obj.props.prim_delays = self.primitive_delays(inst);
        // 37.58: the delay expressions are kept so a parameter named in
        // them (`and #P g (...)`) has a `vpiUse`.
        obj.props.delay_op = self.primitive_delay_operand(inst);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(at);
        let id = self.add(obj);
        self.attributes(inst.attributes(), id, full, false);
        if kind == ObjKind::Udp
            && let Some(d) = udp_definition(inst, &def)
            && let Some(defn) = self.udp_defn(&d)
        {
            self.rel(id, header("vpiUdpDefn"), Operand::Obj(defn));
        }
        for (i, c) in conns.iter().enumerate() {
            let e = if c.kind() == sv_lang::kinds::ExpressionKind::Assignment {
                c.left().unwrap_or(*c)
            } else {
                *c
            };
            let op = self.operand(&e);
            let mut t = Obj::new(ObjKind::PrimTerm, Some(id), "", "");
            t.props.conn_op = op;
            t.props.term_index = i as i32;
            t.props.direction = if i < inouts {
                consts::VPI_INOUT
            } else if i < inouts + outs {
                consts::VPI_OUTPUT
            } else {
                consts::VPI_INPUT
            };
            t.props.file = Some(self.file.clone());
            t.props.line = self.locator.line(at);
            let tid = self.add(t);
            // An output connection is elaborated as an assignment to it.
            let e = if c.kind() == sv_lang::kinds::ExpressionKind::Assignment {
                c.left().unwrap_or(*c)
            } else {
                *c
            };
            self.link(tid, 0, &e);
        }
    }

    /// A UDP's definition object (37.36), interned per definition: its
    /// ports as IO declarations, its table entries, its initial value.
    fn udp_defn(&mut self, d: &Symbol<'_>) -> Option<ObjId> {
        let key = format!("udp:{:?}", d.uid());
        if let Some(&id) = self.typespecs.get(&key) {
            return Some(id);
        }
        let name = d.name().to_owned();
        let ports: Vec<Symbol<'_>> = d.primitive_ports().collect();
        let seq = d.primitive_is_sequential();
        let mut obj = Obj::new(ObjKind::UdpDefn, None, &name, "");
        obj.props.def_name = Some(name.clone());
        obj.props.prim_type = header(if seq { "vpiSeqPrim" } else { "vpiCombPrim" });
        obj.props.size = Some(ports.len().saturating_sub(1) as i32);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(d);
        let id = self.add(obj);
        self.typespecs.insert(key, id);
        let mut out_decl = None;
        for p in &ports {
            let pname = p.name().to_owned();
            let mut io = Obj::new(ObjKind::IODecl, Some(id), &pname, "");
            io.props.direction = match p.primitive_port_direction() {
                sv_lang::PrimitivePortDirection::In => consts::VPI_INPUT,
                _ => consts::VPI_OUTPUT,
            };
            io.props.width = 1;
            io.props.file = Some(self.file.clone());
            io.props.line = self.locator.line(p);
            let io_id = self.add(io);
            if out_decl.is_none() {
                out_decl = Some(io_id);
            }
        }
        for (inputs, output, state) in d.primitive_table() {
            // Decompiled as written: `inputs : state : output` (37.36
            // detail 1), one symbol entry per input (an edge counts once),
            // the state and the output.
            let text = if state.is_empty() {
                format!("{inputs}:{output}")
            } else {
                format!("{inputs}:{state}:{output}")
            };
            let mut symbols = 0;
            let mut in_edge = false;
            for c in inputs.chars() {
                match c {
                    '(' => in_edge = true,
                    ')' => {
                        in_edge = false;
                        symbols += 1;
                    }
                    ' ' | '\t' => {}
                    _ if in_edge => {}
                    _ => symbols += 1,
                }
            }
            symbols += 1 + usize::from(!state.is_empty());
            let mut e = Obj::new(ObjKind::TableEntry, Some(id), "", "");
            e.props.size = Some(symbols as i32);
            e.props.param = Some(ParamValue::Str(text));
            e.props.file = Some(self.file.clone());
            self.add(e);
        }
        // `initial out = v;` (29.6): an initial process assigning it.
        if let Some(v) = d.primitive_init_val()
            && let Some(out) = out_decl
            && let ExprNode::Const {
                value,
                signed,
                const_type,
            } = const_node(&v, sv_lang::kinds::ExpressionKind::IntegerLiteral)
        {
            let rhs = self.model.add_expr(ExprNode::Const {
                value,
                signed,
                const_type,
            });
            let mut st = Obj::new(ObjKind::Stmt, None, "", "");
            st.props.stmt_type = header("vpiAssignment");
            st.props.blocking = true;
            st.props.rels.push((consts::VPI_LHS, Operand::Obj(out)));
            st.props.rels.push((consts::VPI_RHS, Operand::Expr(rhs)));
            let st_id = self.add(st);
            let mut init = Obj::new(ObjKind::Process, None, "", "");
            init.props.stmt_type = header("vpiInitial");
            init.props
                .rels
                .push((consts::VPI_STMT, Operand::Obj(st_id)));
            let init_id = self.add(init);
            self.rel(id, header("vpiInitial"), Operand::Obj(init_id));
        }
        Some(id)
    }

    /// `e` as an operand: a plainly named signal is its object (resolved in
    /// the post-pass, so recorded through `link`-style keys), anything else
    /// an expression node. `None` for an operand with nothing to show.
    fn operand(&mut self, e: &sv_lang::Expression<'_>) -> Option<Operand> {
        self.operand_with_convs(e).0
    }

    /// The conversion `e` (a `Conversion` expression) applies: to its type.
    fn conv_of(e: &sv_lang::Expression<'_>) -> Option<crate::vpi::eval::Conv> {
        let t = e.expr_type()?.canonical();
        Some(crate::vpi::eval::Conv {
            width: t.bit_width() as u32,
            signed: t.is_signed(),
            real: t.is_floating(),
            shortreal: t.is_floating() && t.floating_kind() == FloatKind::ShortReal,
        })
    }

    /// [`Self::operand`], with the implicit conversions slang wrapped `e`
    /// in, innermost first (they are not objects of their own).
    fn operand_with_convs(
        &mut self,
        e: &sv_lang::Expression<'_>,
    ) -> (Option<Operand>, Vec<crate::vpi::eval::Conv>) {
        let outer = self.op_depth == 0 && !self.let_decls.is_empty();
        if outer {
            // The outermost expression names the `let` invocations in it: a
            // caller's hint when the expression is itself an expansion.
            self.let_sites = match self.let_hint.take() {
                Some(h) => h,
                None => {
                    let own = self.let_sites_of_expr(e);
                    if own.is_empty() {
                        self.stmt_sites.clone()
                    } else {
                        own
                    }
                }
            };
        }
        self.op_depth += 1;
        let r = self.operand_with_convs_inner(e);
        self.op_depth -= 1;
        if outer {
            self.let_sites.clear();
        }
        r
    }

    fn operand_with_convs_inner(
        &mut self,
        e: &sv_lang::Expression<'_>,
    ) -> (Option<Operand>, Vec<crate::vpi::eval::Conv>) {
        use sv_lang::kinds::ExpressionKind as K;
        let mut e = unwrap_invalid_expr(*e);
        let mut convs = Vec::new();
        while e.kind() == K::Conversion && e.conversion_is_implicit() != Some(false) {
            if let Some(c) = Self::conv_of(&e) {
                convs.push(c);
            }
            match e.conversion_operand() {
                Some(inner) => e = inner,
                None => return (None, Vec::new()),
            }
        }
        convs.reverse();
        if e.kind() == K::Invalid
            && let Some(f) = self.placeholder_formal(&e)
        {
            return (Some(Operand::Obj(f)), convs);
        }
        (self.operand_inner(&e), convs)
    }

    /// The formal an `Invalid` placeholder stands for (a formal without a
    /// default, 37.57 detail 1), found by its source text.
    fn placeholder_formal(&self, e: &sv_lang::Expression<'_>) -> Option<ObjId> {
        let text = self
            .locator
            .syntax_trees()
            .iter()
            .find_map(|t| e.syntax(t).map(|n| n.text().trim().to_owned()))?;
        self.formal_names
            .iter()
            .find(|(n, _)| *n == text)
            .map(|(_, f)| *f)
    }

    fn operand_inner(&mut self, e: &sv_lang::Expression<'_>) -> Option<Operand> {
        use sv_lang::kinds::ExpressionKind as K;
        let e = *e;
        if let Some(op) = self.let_root(&e) {
            return Some(op);
        }
        if self.formals_by_text
            && let Some(f) = self.placeholder_formal(&e)
        {
            return Some(Operand::Obj(f));
        }
        if e.kind() == K::NamedValue
            && let Some(&f) = e
                .referenced_symbol()
                .and_then(|s| self.formal_by_uid.get(&s.uid()))
        {
            // A formal in its declaration's bound body.
            return Some(Operand::Obj(f));
        }
        if e.kind() == K::NamedValue
            && let Some(sym) = e.referenced_symbol()
            && matches!(
                sym.kind(),
                SymbolKind::LocalAssertionVar | SymbolKind::AssertionPort
            )
            && let Some((_, f)) = self.formal_names.iter().find(|(n, _)| n == sym.name())
        {
            // A local-variable formal in its declaration's bound body: slang
            // binds it as a local assertion variable, not the port.
            return Some(Operand::Obj(*f));
        }
        if e.kind() == K::NamedValue
            && let Some(sym) = e.referenced_symbol()
            && sym.kind() == SymbolKind::Iterator
            && let Some(&(_, v)) = self.loop_vars.iter().rev().find(|(n, _)| n == sym.name())
        {
            // A `foreach` constraint's loop variable.
            return Some(Operand::Obj(v));
        }
        if e.kind() == K::NamedValue
            || (e.kind() == K::HierarchicalValue
                && e.referenced_symbol()
                    .is_some_and(|s| s.kind() == SymbolKind::Parameter))
        {
            // (A hierarchical name of a parameter, `u.P` or `top.P`, 37.58,
            // is resolved through its symbol the same way.)
            // Resolved like any operand: a placeholder node patched in the
            // post-pass into the object itself (see `expr_links`).
            let holder = self.model.add_expr(ExprNode::Op {
                op_type: 0,
                width: 0,
                operands: vec![Operand::Expr(u32::MAX)],
                meta: OpMeta::default(),
            });
            if let (Some(sym), Some(body)) =
                (e.referenced_symbol(), self.link_body(e.referenced_symbol()))
            {
                self.expr_links.push((holder, 0, body, sym.uid()));
            }
            self.pending_plain.push(holder);
            if e.referenced_symbol().is_some_and(|s| {
                s.kind() == SymbolKind::FormalArgument
                    || (s.kind() == SymbolKind::Variable
                        && s.variable_lifetime() == VariableLifetime::Automatic)
            }) {
                self.pending_local.insert(holder);
            }
            return Some(Operand::Expr(holder));
        }
        Some(Operand::Expr(self.expr(&e)))
    }

    /// An expression node for `e` (not a plain name, see [`Self::operand`]).
    /// The body a use of `sym` resolves against in the `expr_links` post-pass:
    /// the instance body, or `None` inside a package or class subroutine,
    /// where only a `ref` formal (a ref obj, 37.15) can be resolved.
    fn link_body(&self, sym: Option<Symbol<'_>>) -> Option<Option<SymbolId>> {
        match self.body.clone() {
            Some(b) => Some(Some(b)),
            None => sym
                .filter(|s| self.tf_ref_by_uid.contains_key(&s.uid()))
                .map(|_| None),
        }
    }

    fn expr(&mut self, e: &sv_lang::Expression<'_>) -> ExprId {
        use sv_lang::kinds::ExpressionKind as K;
        let width = e.expr_type().map_or(0, |t| t.bit_width() as i32);
        let constant = |x: Option<sv_lang::Expression<'_>>| {
            x.and_then(|x| x.constant_value())
                .and_then(|c| c.as_i64())
                .map(|v| v as i32)
        };
        let node = match e.kind() {
            K::IntegerLiteral
            | K::UnbasedUnsizedIntegerLiteral
            | K::RealLiteral
            | K::StringLiteral => match e.constant_value().or_else(|| match e.kind() {
                // An actual of a sequence/property instance is never
                // constant-evaluated by slang; a literal still has its value.
                K::IntegerLiteral => e.integer_literal_value(),
                K::UnbasedUnsizedIntegerLiteral => e.unbased_unsized_literal_value(),
                _ => None,
            }) {
                Some(c) => const_node(&c, e.kind()),
                None => ExprNode::Unsupported("a literal with no value".into()),
            },
            K::ElementSelect
                if e.select_value().is_some_and(|mut b| {
                    // `a.m[i][j]`: the base may itself be a select of an
                    // array member (37.61 detail 1).
                    while b.kind() == K::ElementSelect {
                        match b.select_value() {
                            Some(inner) => b = inner,
                            None => return false,
                        }
                    }
                    b.kind() == K::MemberAccess
                        && b.expr_type()
                            .is_some_and(|t| t.canonical().is_unpacked_array())
                }) =>
            {
                return self.member_element_select(e);
            }
            K::ElementSelect | K::RangeSelect
                if e.select_value().is_some_and(|b| b.kind() != K::NamedValue) =>
            {
                return self.expr_select(e, width);
            }
            K::ElementSelect | K::RangeSelect
                if e.select_value()
                    .and_then(|b| b.expr_type())
                    .is_some_and(|t| t.canonical().is_unpacked_array())
                    || (e.kind() == K::ElementSelect
                        && e.selector().and_then(|s| s.constant_value()).is_none())
                    || (e.kind() == K::RangeSelect && e.range_selection_kind() != Some(0)) =>
            {
                return self.dynamic_select(e, width);
            }
            K::MemberAccess => {
                // `a.b.c` on a named value: the member object (37.26),
                // found once every object exists.
                let mut path = vec![
                    e.member_symbol()
                        .map(|m| m.name().to_owned())
                        .unwrap_or_default(),
                ];
                let mut base = e.operand();
                let mut chain = Vec::new();
                while let Some(b) = base.filter(|b| b.kind() == K::MemberAccess) {
                    chain.push(
                        b.expr_type()
                            .map(|t| (Self::var_kind(&t), t.bit_width() as i32)),
                    );
                    path.push(
                        b.member_symbol()
                            .map(|m| m.name().to_owned())
                            .unwrap_or_default(),
                    );
                    base = b.operand();
                }
                path.reverse();
                // `V.sub.sig` on a virtual interface variable: slang binds the
                // member `sig` directly, so the path through the nested
                // instance is the member's hierarchical path below the
                // interface the variable's type names.
                if path.len() == 1
                    && let Some(b) = base.filter(|b| b.kind() == K::NamedValue)
                    && let Some(def) = b
                        .expr_type()
                        .filter(|t| t.canonical().is_virtual_interface())
                        .and_then(|t| vif_shape(&t.canonical()))
                        .map(|v| v.def)
                    && let Some(full) = e.member_symbol().map(|m| m.hierarchical_path())
                {
                    let comps: Vec<&str> = full.split('.').collect();
                    if let Some(at) = comps.iter().position(|c| *c == def)
                        && at + 2 < comps.len()
                    {
                        path = vec![comps[at + 1..].join(".")];
                    }
                }
                match base.filter(|b| b.kind() == K::NamedValue) {
                    Some(b) => {
                        let id = self.model.add_expr(ExprNode::Member {
                            base: u32::MAX,
                            path: path.join("."),
                        });
                        if let (Some(sym), Some(body)) =
                            (b.referenced_symbol(), self.link_body(b.referenced_symbol()))
                        {
                            self.expr_links.push((id, -1, body, sym.uid()));
                        }
                        self.pending_members.push(id);
                        chain.reverse();
                        if let Some(c) = chain.into_iter().collect::<Option<Vec<_>>>() {
                            self.member_chain.insert(id, c);
                        }
                        if let Some(t) = e.expr_type() {
                            self.member_types.insert(id, (Self::var_kind(&t), width));
                        }
                        return id;
                    }
                    None => ExprNode::Unsupported("a member select of a non-signal".into()),
                }
            }
            K::Conversion => {
                // An explicit cast (`T'(x)`, 6.24.1): a vpiCastOp operation.
                let (inner, mut convs) = match e.conversion_operand() {
                    Some(i) => self.operand_with_convs(&i),
                    None => (None, Vec::new()),
                };
                convs.extend(Self::conv_of(e));
                let ty = e.expr_type();
                let meta = OpMeta {
                    signed: ty.is_some_and(|t| t.is_signed()),
                    real: ty.is_some_and(|t| t.is_floating()),
                    convs: vec![convs],
                    typespec: ty.and_then(|t| self.typespec(&t)),
                    strong: false,
                    soft: false,
                    slice: 0,
                    ..OpMeta::default()
                };
                ExprNode::Op {
                    op_type: header("vpiCastOp"),
                    width,
                    operands: inner.into_iter().collect(),
                    meta,
                }
            }
            // `[lo:hi]` (11.4.13, 18.5.4): a range object (37.22).
            K::ValueRange => {
                let bounds: Vec<sv_lang::Expression<'_>> = e
                    .as_sem_node()
                    .children()
                    .into_iter()
                    .filter_map(|n| n.as_expression())
                    .collect();
                match (
                    bounds.first().and_then(|l| self.operand(l)),
                    bounds.get(1).and_then(|r| self.operand(r)),
                ) {
                    (Some(left), Some(right)) => ExprNode::ValueRange { left, right },
                    _ => ExprNode::Unsupported("a value range without both bounds".into()),
                }
            }
            // `e inside { set }` (11.4.13): its operand, then the set's members.
            K::Inside => {
                let mut ops: Vec<Operand> = e
                    .inside_left()
                    .and_then(|l| self.operand(&l))
                    .into_iter()
                    .collect();
                ops.extend(e.inside_range_list().iter().filter_map(|x| self.operand(x)));
                ExprNode::Op {
                    op_type: header("vpiInsideOp"),
                    width: 1,
                    operands: ops,
                    meta: OpMeta::default(),
                }
            }
            // `new` (8.7): a call of the class's constructor function, a
            // method func call named `new` (with no vpiFunction when the class
            // declares no constructor).
            K::NewClass => {
                if let Some(c) = e.new_class_constructor_call() {
                    let id = self.expr(&c);
                    if let Some(ExprNode::Call {
                        method,
                        name,
                        prefix,
                        ..
                    }) = self.model.expr_mut(id)
                    {
                        *method = true;
                        *prefix = None;
                        "new".clone_into(name);
                    }
                    return id;
                }
                ExprNode::Call {
                    func: None,
                    name: "new".to_owned(),
                    sys: false,
                    args: Vec::new(),
                    width,
                    prefix: None,
                    method: true,
                    with: None,
                    folded: None,
                }
            }
            // `new(actuals)` of a covergroup (19.4): a method call named `new`
            // whose arguments are the actuals written in the source, so a
            // design object named there is used.
            K::NewCovergroup => {
                let args: Vec<Operand> = e
                    .new_covergroup_arguments()
                    .iter()
                    .filter_map(|a| self.operand(a))
                    .collect();
                ExprNode::Call {
                    func: None,
                    name: "new".to_owned(),
                    sys: false,
                    args,
                    width,
                    prefix: None,
                    method: true,
                    with: None,
                    folded: None,
                }
            }
            K::Call => {
                let sys = e.system_subroutine();
                let name = match &sys {
                    Some(m) => m.name().to_owned(),
                    None => e
                        .call_subroutine()
                        .map(|s| s.name().to_owned())
                        .unwrap_or_default(),
                };
                let callee = e.call_subroutine();
                let func = callee.and_then(|s| self.model.find(&s.hierarchical_path()));
                // A built-in method's object is slang's first argument; a
                // class method's is its `this` (37.42 detail 2), which slang
                // also lists first.
                let this = e.call_this_class();
                let operands = e.operands();
                let builtin = sys.as_ref().is_some_and(|m| !m.name().starts_with('$'))
                    || (this.is_some() && receiver_listed(e));
                let prefix = match this {
                    Some(t) => self.operand(&t),
                    None if builtin => operands.first().and_then(|a| self.operand(a)),
                    None => None,
                };
                let args: Vec<Operand> = operands
                    .iter()
                    .skip(usize::from(builtin))
                    .filter_map(|a| self.operand(a))
                    .collect();
                // A user function slang can constant-evaluate (constant
                // arguments, no side effects) has a value to serve through
                // `vpi_get_value`; every other call is refused by name there.
                let folded = (sys.is_none() && !builtin && this.is_none() && callee.is_some())
                    .then(|| self.eval.eval_constant(*e))
                    .flatten()
                    .map(|c| const_node(&c, K::Call))
                    .filter(|n| !matches!(n, ExprNode::Unsupported(_)))
                    .map(|n| Operand::Expr(self.model.add_expr(n)));
                let with = self.call_with(e);
                let node = ExprNode::Call {
                    func,
                    name,
                    sys: sys.is_some() && !builtin,
                    args,
                    width,
                    prefix,
                    method: builtin || this.is_some(),
                    with,
                    folded,
                };
                if func.is_none()
                    && let Some(s) = callee
                {
                    let id = self.model.add_expr(node);
                    self.tf_call_links.push((id, s.uid()));
                    return id;
                }
                node
            }
            K::SimpleAssignmentPattern
            | K::StructuredAssignmentPattern
            | K::ReplicatedAssignmentPattern => {
                let mut ops = Vec::new();
                let mut convs = Vec::new();
                // 37.59 detail 7: `'{n{...}}` is a vpiMultiAssignmentPatternOp
                // whose first operand is the multiplier.
                let multi = e.kind() == K::ReplicatedAssignmentPattern;
                let mut elems: Vec<_> = e.replicated_pattern_count().into_iter().collect();
                elems.extend(e.pattern_elements());
                for p in elems {
                    let (o, c) = self.operand_with_convs(&p);
                    if let Some(o) = o {
                        ops.push(o);
                        convs.push(c);
                    }
                }
                let ty = e.expr_type();
                ExprNode::Op {
                    op_type: header(if multi {
                        "vpiMultiAssignmentPatternOp"
                    } else {
                        "vpiAssignmentPatternOp"
                    }),
                    width,
                    operands: ops,
                    meta: OpMeta {
                        signed: false,
                        real: false,
                        convs,
                        typespec: ty.and_then(|t| self.typespec(&t)),
                        strong: false,
                        soft: false,
                        slice: 0,
                        ..OpMeta::default()
                    },
                }
            }
            K::ElementSelect | K::RangeSelect => {
                let base = e.select_value();
                let named = base.filter(|b| b.kind() == K::NamedValue);
                let bounds = if e.kind() == K::ElementSelect {
                    constant(e.selector()).map(|i| (i, i))
                } else if e.range_selection_kind() == Some(0) {
                    constant(e.range_left()).zip(constant(e.range_right()))
                } else {
                    None
                };
                match (named, bounds) {
                    (Some(b), Some((l, r))) => {
                        let node = if e.kind() == K::ElementSelect {
                            ExprNode::BitSelect {
                                base: u32::MAX,
                                index: l,
                            }
                        } else {
                            ExprNode::PartSelect {
                                base: u32::MAX,
                                left: l,
                                right: r,
                            }
                        };
                        let id = self.model.add_expr(node);
                        // 37.58: the folded bounds still name their parameters.
                        let mut named = Vec::new();
                        for part in [e.selector(), e.range_left(), e.range_right()]
                            .into_iter()
                            .flatten()
                        {
                            Self::named_parameters(&part, &mut named);
                        }
                        for p in named {
                            self.param_links.push((id, p));
                        }
                        if let (Some(sym), Some(body)) =
                            (b.referenced_symbol(), self.link_body(b.referenced_symbol()))
                        {
                            self.expr_links.push((id, -1, body, sym.uid()));
                        } else if let Some(n) = self.model.expr_mut(id) {
                            *n = ExprNode::Unsupported("a select of a non-signal".into());
                        }
                        return id;
                    }
                    _ => ExprNode::Unsupported(
                        "a select with a non-constant index (vpiVarSelect)".into(),
                    ),
                }
            }
            K::UnaryOp
            | K::BinaryOp
            | K::ConditionalOp
            | K::MinTypMax
            | K::Concatenation
            | K::Replication
            | K::Streaming => {
                let op_type = op_type_of(e);
                let parts: Vec<sv_lang::Expression<'_>> = match e.kind() {
                    K::ConditionalOp => {
                        let (t, f) = (e.true_value(), e.false_value());
                        let mut v: Vec<_> = e.conditions().iter().map(|c| c.expr()).collect();
                        v.extend(t);
                        v.extend(f);
                        v
                    }
                    K::Replication => {
                        let mut v: Vec<_> = e.replication_count().into_iter().collect();
                        if let Some(c) = e.replication_concat() {
                            v.extend(c.operands());
                        }
                        v
                    }
                    // A concatenation's operands are its own list; one that
                    // bound with an error is still an operand.
                    K::Concatenation => {
                        let v: Vec<_> = e.operands().into_iter().collect();
                        if v.is_empty() {
                            e.children_with_invalid()
                                .iter()
                                .filter_map(|c| c.as_expression())
                                .collect()
                        } else {
                            v
                        }
                    }
                    K::Streaming => {
                        let streams = e.streams();
                        // `{<< {a with [i +: 4]}}` re-slices an operand
                        // (11.4.14.4); that has no operand object.
                        if streams.iter().any(|s| s.with_expr().is_some()) {
                            return self.model.add_expr(ExprNode::Unsupported(
                                "a streaming concatenation with a `with` clause".into(),
                            ));
                        }
                        streams.iter().map(|s| s.operand()).collect()
                    }
                    // `children_with_invalid`: an operand that bound with an
                    // error (an untyped formal placeholder) is still one.
                    _ => e
                        .children_with_invalid()
                        .iter()
                        .filter_map(|c| c.as_expression())
                        .collect(),
                };
                // slang keeps no operands of a concatenation that bound with
                // an error (an untyped formal among them): refuse by name
                // instead of exposing an operation with none.
                if parts.is_empty() && matches!(e.kind(), K::Concatenation | K::Replication) {
                    return self.model.add_expr(ExprNode::Unsupported(
                        "a concatenation with an untyped formal operand (slang drops its operands)"
                            .into(),
                    ));
                }
                match op_type {
                    Some(op_type) => {
                        let ty = e.expr_type();
                        let id = self.model.add_expr(ExprNode::Op {
                            op_type,
                            width,
                            operands: Vec::new(),
                            meta: OpMeta::default(),
                        });
                        let mut ops = Vec::new();
                        let mut all_convs = Vec::new();
                        for p in &parts {
                            let (o, c) = self.operand_with_convs(p);
                            if let Some(o) = o {
                                ops.push(o);
                                all_convs.push(c);
                            }
                        }
                        if let Some(ExprNode::Op { operands, meta, .. }) = self.model.expr_mut(id) {
                            *operands = ops;
                            *meta = OpMeta {
                                signed: ty.is_some_and(|t| t.is_signed()),
                                real: ty.is_some_and(|t| t.is_floating()),
                                convs: all_convs,
                                typespec: None,
                                strong: false,
                                soft: false,
                                slice: e
                                    .streaming_slice_size()
                                    .map_or(0, |n| u32::try_from(n).unwrap_or(u32::MAX)),
                                ..OpMeta::default()
                            };
                        }
                        return id;
                    }
                    None => ExprNode::Unsupported(format!(
                        "an operator without a vpiOpType ({:?})",
                        e.kind()
                    )),
                }
            }
            // An omitted argument (`$write(a, , b)`) is a `vpiNullOp`
            // operation (37.42 detail 8).
            sv_lang::kinds::ExpressionKind::EmptyArgument => ExprNode::Op {
                op_type: header("vpiNullOp"),
                width: 0,
                operands: Vec::new(),
                meta: OpMeta::default(),
            },
            other => ExprNode::Unsupported(format!("an expression of kind {other:?}")),
        };
        self.model.add_expr(node)
    }

    /// The body of the `let` declaration `sym` when it is a concatenation or
    /// replication slang built without the operands of an untyped formal
    /// (`let l(x) = {x, a}`; the bad concatenation keeps none, or for a
    /// replication only its count), rebuilt from the declaration's syntax:
    /// each operand is bound in the declaration's scope (37.57) with the
    /// formal itself standing for its placeholder. `None` when the body is
    /// no such concatenation or an operand does not bind (the caller then
    /// refuses by name).
    fn let_body_concat(
        &mut self,
        sym: &Symbol<'_>,
        body: &sv_lang::Expression<'_>,
    ) -> Option<Operand> {
        use sv_lang::AstNode;
        use sv_lang::kinds::ExpressionKind as K;
        let empty = match body.kind() {
            K::Concatenation => body.operands().is_empty(),
            K::Replication => body
                .replication_concat()
                .is_none_or(|c| c.operands().is_empty()),
            _ => false,
        };
        // A bad concatenation nested in a larger body (`{x, a} + 1`) leaves
        // the enclosing operation bad too; it is rebuilt operand by operand.
        if !empty && !has_empty_concat(body) {
            return None;
        }
        let width = body.expr_type().map_or(0, |t| t.bit_width() as i32);
        let trees = self.locator.syntax_trees();
        let node = trees.iter().find_map(|t| {
            sym.syntax(t)
                .and_then(sv_lang::nodes::LetDeclarationSyntax::cast)
                .map(|n| n.expr().syntax())
        })?;
        self.syntax_operand(node, *sym, width)
    }

    /// One operand of [`Self::let_body_concat`] from its syntax `node`.
    fn syntax_operand(
        &mut self,
        node: sv_lang::Node<'_>,
        scope: Symbol<'_>,
        width: i32,
    ) -> Option<Operand> {
        use sv_lang::AstNode;
        use sv_lang::nodes::{
            BinaryExpressionSyntax, ConcatenationExpressionSyntax,
            MultipleConcatenationExpressionSyntax, ParenthesizedExpressionSyntax,
            PrefixUnaryExpressionSyntax,
        };
        // Parentheses leave no node (slang drops them).
        if let Some(p) = ParenthesizedExpressionSyntax::cast(node) {
            return self.syntax_operand(p.expression().syntax(), scope, width);
        }
        let (op_type, items): (&str, Vec<sv_lang::Node<'_>>) = if let Some(c) =
            ConcatenationExpressionSyntax::cast(node)
        {
            (
                "vpiConcatOp",
                c.expressions().iter().map(|x| x.syntax()).collect(),
            )
        } else if let Some(r) = MultipleConcatenationExpressionSyntax::cast(node) {
            let mut v = vec![r.expression().syntax()];
            v.extend(r.concatenation().expressions().iter().map(|x| x.syntax()));
            ("vpiMultiConcatOp", v)
        } else {
            let text = node.text().trim().to_owned();
            if let Some((_, f)) = self.formal_names.iter().find(|(n, _)| *n == text) {
                return Some(Operand::Obj(*f));
            }
            let eval = self.eval;
            let bound = unwrap_invalid_expr(eval.bind_expression(node, scope)?);
            if !bound.is_bad() {
                return self.operand(&bound);
            }
            // A unary/binary operation over a bad concatenation: its
            // operator is known, its operands are rebuilt in turn.
            let op = op_type_of(&bound)?;
            let w = bound.expr_type().map_or(0, |t| t.bit_width() as i32);
            let kids: Vec<sv_lang::Node<'_>> = if let Some(b) = BinaryExpressionSyntax::cast(node) {
                vec![b.left().syntax(), b.right().syntax()]
            } else {
                let u = PrefixUnaryExpressionSyntax::cast(node)?;
                vec![u.operand().syntax()]
            };
            let mut ops = Vec::new();
            for k in kids {
                ops.push(self.syntax_operand(k, scope, 0)?);
            }
            let convs = vec![Vec::new(); ops.len()];
            let id = self.model.add_expr(ExprNode::Op {
                op_type: op,
                width: w,
                operands: ops,
                meta: OpMeta {
                    convs,
                    signed: bound.expr_type().is_some_and(|t| t.is_signed()),
                    ..OpMeta::default()
                },
            });
            return Some(Operand::Expr(id));
        };
        let mut ops = Vec::new();
        for item in items {
            ops.push(self.syntax_operand(item, scope, 0)?);
        }
        let convs = vec![Vec::new(); ops.len()];
        let id = self.model.add_expr(ExprNode::Op {
            op_type: header(op_type),
            width,
            operands: ops,
            meta: OpMeta {
                convs,
                ..OpMeta::default()
            },
        });
        Some(Operand::Expr(id))
    }

    /// `a.arr[i]`: an element of a fixed-size unpacked array member (37.19,
    /// 37.61 detail 1). The member resolves like any member select (an
    /// object, or a prefixed member of a class or virtual interface
    /// variable); the element of a prefixed member is read when asked for.
    fn member_element_select(&mut self, e: &sv_lang::Expression<'_>) -> ExprId {
        let unsupported =
            |m: &mut Self, why: &str| m.model.add_expr(ExprNode::Unsupported(why.into()));
        let Some(b) = e.select_value() else {
            return unsupported(self, "a select with no base");
        };
        let Some(bty) = b.expr_type().map(|t| t.canonical()) else {
            return unsupported(self, "a select of an untyped value");
        };
        let range = bty.fixed_unpacked_array_range();
        let el = bty.element_type().map(|t| t.canonical());
        // An element is an integral, real or string scalar, a handle, an
        // unpacked struct, or a sub-array of one (`c.m[i]` of `int m[2][3]`);
        // what has no fixed stored form (a collection) is refused.
        let Some(el) = el.filter(|t| {
            vj_sim::state::storage::storage_width(t).is_some()
                && !vj_sim::state::storage::is_collection(t)
        }) else {
            return unsupported(
                self,
                "a select of an array member whose element has no fixed stored form",
            );
        };
        let sub = el.is_unpacked_array();
        let elem_kind = if sub {
            ObjKind::RegArray
        } else if el.is_integral() {
            ObjKind::Reg
        } else {
            Self::var_kind(&el)
        };
        let elem_bits = vj_sim::state::storage::storage_width(&el).unwrap_or(0) as i32;
        let elem_width = if sub {
            el.fixed_unpacked_array_range().width() as i32
        } else if el.is_integral() {
            el.bit_width() as i32
        } else {
            elem_bits
        };
        let Some(prefix) = self.operand(&b) else {
            return unsupported(self, "a select of an unresolved array member");
        };
        let Some(index) = e.selector().and_then(|s| self.operand(&s)) else {
            return unsupported(self, "a select with no index");
        };
        let text = e
            .selector()
            .map(|s| self.expr_source_text(&s))
            .unwrap_or_default();
        self.model.add_expr(ExprNode::PrefixedElement {
            prefix,
            index,
            text,
            lo: range.left.min(range.right),
            count: (range.left - range.right).abs() + 1,
            elem_width,
            four_state: el.is_four_state(),
            signed: el.is_signed(),
            elem_kind,
            elem_bits,
        })
    }

    /// A select of an expression's value (`mem[i][3:0]`, `{a,b}[2]`).
    fn expr_select(&mut self, e: &sv_lang::Expression<'_>, width: i32) -> ExprId {
        use super::model::Sel;
        use sv_lang::kinds::ExpressionKind as K;
        let Some(b) = e.select_value() else {
            return self
                .model
                .add_expr(ExprNode::Unsupported("a select with no base".into()));
        };
        let Some(bty) = b.expr_type().map(|t| t.canonical()) else {
            return self
                .model
                .add_expr(ExprNode::Unsupported("a select of an untyped value".into()));
        };
        if bty.is_unpacked_array() {
            return self.model.add_expr(ExprNode::Unsupported(
                "a select from an unpacked subarray".into(),
            ));
        }
        // A select of a non-integral base can only be the untyped
        // placeholder of a formal in a declaration body (`x[1:0]` of
        // `let l(x) = x[1:0]`; LRM 37.57): the formal has no type until an
        // instance, so the select is modelled over a four-state vector as
        // wide as the select reaches and is never readable.
        let range = if !bty.is_integral() {
            (width.max(1) - 1, 0)
        } else if bty.is_packed_array() {
            let r = bty.fixed_range();
            (r.left, r.right)
        } else {
            (bty.bit_width() as i32 - 1, 0)
        };
        let constant = |x: Option<sv_lang::Expression<'_>>| {
            x.and_then(|x| x.constant_value())
                .and_then(|c| c.as_i64())
                .map(|v| v as i32)
        };
        let sel = if e.kind() == K::ElementSelect {
            e.selector().and_then(|i| self.operand(&i)).map(Sel::Bit)
        } else if e.range_selection_kind() == Some(0) {
            constant(e.range_left())
                .zip(constant(e.range_right()))
                .map(|(l, r)| Sel::Part(l, r))
        } else {
            e.range_left()
                .and_then(|s| self.operand(&s))
                .map(|s| Sel::Indexed(s, e.range_selection_kind() == Some(1)))
        };
        let (Some(base), Some(sel)) = (self.operand(&b), sel) else {
            return self
                .model
                .add_expr(ExprNode::Unsupported("an incomplete select".into()));
        };
        let text = if e.kind() == K::ElementSelect {
            e.selector()
        } else {
            e.range_left()
        }
        .map(|x| self.expr_source_text(&x))
        .unwrap_or_default();
        self.model.add_expr(ExprNode::ExprSelect {
            base,
            sel,
            text,
            range,
            width,
            count: constant(e.range_right()).unwrap_or(width),
            four_state: !bty.is_integral() || bty.is_four_state(),
        })
    }

    /// The source text of `e` with whitespace removed (looking through the
    /// implicit conversions slang wraps it in); empty if no syntax tree has it.
    fn expr_source_text(&self, e: &sv_lang::Expression<'_>) -> String {
        use sv_lang::kinds::ExpressionKind as K;
        let mut e = *e;
        while e.kind() == K::Conversion && e.conversion_is_implicit() != Some(false) {
            match e.conversion_operand() {
                Some(inner) => e = inner,
                None => break,
            }
        }
        self.locator
            .syntax_trees()
            .iter()
            .find_map(|t| e.syntax(t))
            .map(|n| n.text().split_whitespace().collect::<String>())
            .unwrap_or_default()
    }

    /// A select whose index is an expression (`vpiVarSelect` of an array
    /// element, `vpiBitSelect` of a vector bit) or an indexed part select
    /// (`vpiIndexedPartSelect`), of a named net or variable.
    fn dynamic_select(&mut self, e: &sv_lang::Expression<'_>, width: i32) -> ExprId {
        use sv_lang::kinds::ExpressionKind as K;
        let base = e.select_value().filter(|b| b.kind() == K::NamedValue);
        let Some(b) = base else {
            return self
                .model
                .add_expr(ExprNode::Unsupported("a select of a non-signal".into()));
        };
        let bty = b.expr_type().map(|t| t.canonical());
        let array = bty.is_some_and(|t| t.is_unpacked_array());
        let four_state = bty
            .map(|t| {
                let mut t = t;
                while t.is_unpacked_array() {
                    match t.element_type() {
                        Some(el) => t = el.canonical(),
                        None => break,
                    }
                }
                t.is_four_state()
            })
            .unwrap_or(true);
        let node = if e.kind() == K::ElementSelect {
            let index = e.selector().and_then(|s| self.operand(&s));
            let text = e
                .selector()
                .map(|s| self.expr_source_text(&s))
                .unwrap_or_default();
            match index {
                Some(index) => ExprNode::IndexSelect {
                    base: u32::MAX,
                    index,
                    text,
                    width,
                    array,
                    four_state,
                },
                None => ExprNode::Unsupported("a select with no index".into()),
            }
        } else if e.range_selection_kind() == Some(0) {
            ExprNode::Unsupported("a slice of an unpacked array".into())
        } else {
            let text = e
                .range_left()
                .map(|s| self.expr_source_text(&s))
                .unwrap_or_default();
            match e.range_left().and_then(|s| self.operand(&s)) {
                Some(start) => ExprNode::IndexedPartSelect {
                    base: u32::MAX,
                    start,
                    text,
                    width,
                    count: e
                        .range_right()
                        .and_then(|x| x.constant_value())
                        .and_then(|c| c.as_i64())
                        .map_or(width, |v| v as i32),
                    up: e.range_selection_kind() == Some(1),
                    four_state,
                },
                None => ExprNode::Unsupported("an indexed part select with no base".into()),
            }
        };
        let id = self.model.add_expr(node);
        if let (Some(sym), Some(body)) =
            (b.referenced_symbol(), self.link_body(b.referenced_symbol()))
        {
            self.expr_links.push((id, -1, body, sym.uid()));
        }
        id
    }

    /// Whether a module path is the `ifnone` one of its terminals: a
    /// state-dependent path with no `if` condition (30.4.3).
    fn is_ifnone(&self, path: &Symbol<'_>) -> bool {
        path.timing_path_is_state_dependent() && path.timing_path_condition_expr().is_none()
    }

    /// A module path's input and output terminals as text, the key an
    /// `ifnone` path shares with the conditional paths it complements.
    fn path_ends(&self, path: &Symbol<'_>) -> String {
        let text = |e: sv_lang::Expression<'_>| self.expr_source_text(&e);
        let ins: Vec<String> = path.timing_path_inputs().map(text).collect();
        let outs: Vec<String> = path.timing_path_outputs().map(text).collect();
        format!("{}>{}", ins.join(","), outs.join(","))
    }

    /// A module path (37.39) and its input, output and data terminals, its
    /// condition and delay expressions.
    fn mod_path(&mut self, path: &Symbol<'_>, parent: ObjId, has_ifnone: bool) {
        let mut obj = Obj::new(ObjKind::ModPath, Some(parent), "", "");
        obj.props.path_key = self.body.clone().map(|b| (b, path.uid()));
        obj.props.path_type = match path.timing_path_connection_kind() {
            sv_lang::TimingPathConnectionKind::Full => 1,
            sv_lang::TimingPathConnectionKind::Parallel => 2,
        };
        obj.props.polarity = match path.timing_path_polarity() {
            sv_lang::TimingPathPolarity::Positive => 1,
            sv_lang::TimingPathPolarity::Negative => 2,
            sv_lang::TimingPathPolarity::Unknown => 3,
        };
        obj.props.data_polarity = match path.timing_path_edge_polarity() {
            sv_lang::TimingPathPolarity::Positive => 1,
            sv_lang::TimingPathPolarity::Negative => 2,
            sv_lang::TimingPathPolarity::Unknown => 3,
        };
        obj.props.has_ifnone = has_ifnone;
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(path);
        let id = self.add(obj);
        // The path's `if (cond)` and its delay expressions, in order.
        if let Some(ce) = path.timing_path_condition_expr() {
            let c = self.operand(&ce);
            self.fold_if_unmodelled(&ce, c);
            if let Some(c) = c {
                self.rel(id, consts::VPI_CONDITION, c);
            }
        }
        let delays: Vec<sv_lang::Expression<'_>> = path.timing_path_delays().collect();
        for d in delays {
            let op = self.operand(&d);
            self.fold_if_unmodelled(&d, op);
            if let Some(d) = op {
                self.rel(id, consts::VPI_DELAY, d);
            }
        }
        let path_full = self
            .model
            .get(id)
            .map(|o| o.full_name.clone())
            .unwrap_or_default();
        self.attributes(path.attributes(), id, &path_full, false);
        // `vpiEdge` of an input term: the path's `posedge`/`negedge`/`edge`.
        let header = |n: &str| crate::vpi::consts::value_of(n).expect("a header constant") as i32;
        let edge = match path.timing_path_edge_identifier() {
            sv_lang::EdgeKind::PosEdge => header("vpiPosedge"),
            sv_lang::EdgeKind::NegEdge => header("vpiNegedge"),
            sv_lang::EdgeKind::BothEdges => header("vpiAnyEdge"),
            sv_lang::EdgeKind::None => header("vpiNoEdge"),
        };
        // (direction, is the edge-sensitive data source, edge, expression)
        let mut terms: Vec<(i32, bool, i32, sv_lang::Expression<'_>)> = path
            .timing_path_inputs()
            .map(|e| (consts::VPI_INPUT, false, edge, e))
            .chain(
                path.timing_path_outputs()
                    .map(|e| (consts::VPI_OUTPUT, false, 0, e)),
            )
            .collect();
        if let Some(e) = path.timing_path_edge_source_expr() {
            terms.push((consts::VPI_INPUT, true, 0, e));
        }
        for (dir, data_in, edge, e) in terms {
            let op = self.operand(&e);
            self.fold_if_unmodelled(&e, op);
            let mut t = Obj::new(ObjKind::PathTerm, Some(id), "", "");
            t.props.direction = dir;
            t.props.data_in = data_in;
            t.props.prim_type = edge;
            t.props.conn_op = op;
            t.props.file = Some(self.file.clone());
            t.props.line = self.locator.line(path);
            let tid = self.add(t);
            self.link(tid, 0, &e);
        }
    }

    /// An array of primitive instances and its elements.
    fn primitive_array(
        &mut self,
        array: &Symbol<'_>,
        parent: ObjId,
        parent_name: &str,
        name: &str,
    ) {
        let full = format!("{parent_name}.{name}");
        let range = array.instance_array_range();
        let elements: Vec<Symbol<'_>> = array.instance_array_elements().collect();
        let mut obj = Obj::new(ObjKind::PrimitiveArray, Some(parent), name, &full);
        obj.props.size = Some(elements.len() as i32);
        obj.props.range = Some((range.left, range.right));
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(array);
        let id = self.add(obj);
        let mut array_type = consts::VPI_GATE_ARRAY;
        for (i, e) in elements.iter().enumerate() {
            if e.kind() != SymbolKind::PrimitiveInstance {
                continue;
            }
            let idx = element_index(range, i);
            // slang slices a wide terminal with the leftmost element on bit 0,
            // where LRM 28.3.5 puts the leftmost element on the most
            // significant slice (`ar3 (out[3], ...)`, 28.3.5 example 2): an
            // element takes the terminal connections slang gave its mirror.
            let src = elements.get(elements.len() - 1 - i).unwrap_or(e);
            self.primitive(
                e,
                id,
                &format!("{name}[{idx}]"),
                &format!("{full}[{idx}]"),
                Some(idx),
                array,
                src,
            );
            if let Some(k) = self
                .model
                .children(id)
                .last()
                .and_then(|&c| self.model.get(c))
            {
                array_type = match k.kind {
                    ObjKind::Switch => consts::VPI_SWITCH_ARRAY,
                    ObjKind::Udp => consts::VPI_UDP_ARRAY,
                    _ => consts::VPI_GATE_ARRAY,
                };
            }
        }
        if let Some(p) = self.model.props_mut(id) {
            p.array_type = array_type;
        }
    }

    /// A continuous assignment (37.36): its strength, its left-hand side
    /// (when a plain name) and the signals its right-hand side reads.
    fn cont_assign(&mut self, assign: &Symbol<'_>, parent: ObjId) {
        let mut obj = Obj::new(ObjKind::ContAssign, Some(parent), "", "");
        let given = assign.continuous_assign_drive_strength();
        obj.props.strength0 = strength_const(given.strength0, false);
        obj.props.strength1 = strength_const(given.strength1, false);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(assign);
        let id = self.add(obj);
        self.assign_delay(assign.continuous_assign_delay(), assign, id);
        let assign_full = self
            .model
            .get(id)
            .map(|o| o.full_name.clone())
            .unwrap_or_default();
        self.attributes(assign.attributes(), id, &assign_full, false);
        let Some(a) = assign.continuous_assign_assignment() else {
            return;
        };
        if let Some(l) = a.left() {
            self.link(id, 0, &l);
            // The size of a select target is the select's, not the net's (37.47).
            let w = l.expr_type().map_or(0, |t| t.bit_width() as i32);
            if let Some(p) = self.model.props_mut(id) {
                p.width = w;
            }
            let op = self.operand(&l);
            if let Some(p) = self.model.props_mut(id) {
                p.conn_op = op;
            }
        }
        if let Some(r) = a.right() {
            self.link(id, 1, &r);
            self.let_hint = Some(self.let_sites_of_expr(&a));
            let mut op = self.operand(&r);
            self.let_hint = None;
            // A `let` instance on the right-hand side (37.57).
            if let Some(body) = op
                && !matches!(
                    body,
                    Operand::Expr(x) if matches!(self.model.expr(x), Some(ExprNode::LetInst { .. }))
                )
            {
                let use_site = self.locator.syntax_trees().iter().find_map(|t| {
                    use sv_lang::AstNode;
                    let n = sv_lang::nodes::BinaryExpressionSyntax::cast(a.syntax(t)?)?;
                    Some(n.right().syntax().text().to_owned())
                });
                let expanded = self
                    .locator
                    .syntax_trees()
                    .iter()
                    .find_map(|t| r.syntax(t).map(|n| n.text().to_owned()));
                if let Some(use_site) = use_site {
                    let width = r.expr_type().map_or(0, |t| t.bit_width() as i32);
                    op = Some(self.let_instance(
                        &use_site,
                        expanded.as_deref(),
                        id,
                        body,
                        width,
                        None,
                        &[],
                    ));
                }
            }
            if let Some(p) = self.model.props_mut(id) {
                p.rhs_op = op;
            }
            let mut stack = vec![r.as_sem_node()];
            while let Some(n) = stack.pop() {
                if let Some(e) = n.as_expression()
                    && e.kind() == sv_lang::kinds::ExpressionKind::NamedValue
                {
                    self.link(id, 2, &e);
                }
                stack.extend(n.children());
            }
        }
    }

    /// The continuous assignment of a net declared with one (`wire w =
    /// expr;`, 37.47): `vpiNetDeclAssign` on it and on the net.
    fn net_decl_assign(
        &mut self,
        net: &Symbol<'_>,
        init: &sv_lang::Expression<'_>,
        parent: ObjId,
        parent_name: &str,
    ) {
        let Some(target) = self.model.find(&format!("{parent_name}.{}", net.name())) else {
            return;
        };
        let mut obj = Obj::new(ObjKind::ContAssign, Some(parent), "", "");
        let given = net.net_drive_strength();
        obj.props.strength0 = strength_const(given.strength0, false);
        obj.props.strength1 = strength_const(given.strength1, false);
        obj.props.net_decl = true;
        obj.props.conn = Some(target);
        obj.props.conn_op = Some(Operand::Obj(target));
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(net);
        let id = self.add(obj);
        self.assign_delay(net.net_delay(), net, id);
        if let Some(p) = self.model.props_mut(target) {
            p.net_decl = true;
        }
        self.link(id, 1, init);
        self.let_hint = Some(self.let_sites_of_symbol(net));
        let op = self.operand(init);
        self.let_hint = None;
        if let Some(p) = self.model.props_mut(id) {
            p.rhs_op = op;
        }
        let mut stack = vec![init.as_sem_node()];
        while let Some(n) = stack.pop() {
            if let Some(e) = n.as_expression()
                && e.kind() == sv_lang::kinds::ExpressionKind::NamedValue
            {
                self.link(id, 2, &e);
            }
            stack.extend(n.children());
        }
    }

    fn package(&mut self, package: &Symbol<'_>) {
        let name = package.name().to_owned();
        let mut obj = Obj::new(ObjKind::Package, None, &name, &format!("{name}::"));
        obj.props.def_name = Some(name);
        obj.props.automatic =
            package.package_default_lifetime() == Some(VariableLifetime::Automatic);
        obj.props.file = Some(self.file.clone());
        obj.props.line = self.locator.line(package);
        let id = self.add(obj);
        self.attributes(
            package.attributes(),
            id,
            &format!("{}::", package.name()),
            false,
        );
        // Its tasks and functions (37.41 detail 5: `pk::f`).
        for m in package.members() {
            if m.kind() == SymbolKind::Subroutine {
                self.task_func(&m, id, package.name(), "::");
            }
            // Its parameters (37.58: `pkg::P` is a vpiUse of `P`).
            if m.kind() == SymbolKind::Parameter {
                self.parameter_sep(&m, id, package.name(), "::");
            }
        }
    }
}

/// The qualifiers of a DPI import declaration.
struct DpiImport {
    /// `DPI` or `DPI-C`.
    spec: String,
    pure: bool,
    context: bool,
    /// The C linkage name (the SV name unless `cname =` is written).
    ident: String,
}

/// Reads `import "DPI-C" [context|pure] [cname =] function|task name (...)`
/// (35.5.4). `fallback` is the SV name, the C name when none is written.
fn parse_dpi_import(text: &str, fallback: &str) -> DpiImport {
    let head = text.split('(').next().unwrap_or(text);
    let spaced = head.replace('=', " = ");
    let spec = spaced.split('"').nth(1).unwrap_or("DPI-C").to_owned();
    let words: Vec<&str> = spaced
        .rsplit('"')
        .next()
        .unwrap_or("")
        .split_whitespace()
        .collect();
    let ident = words
        .iter()
        .position(|w| *w == "=")
        .and_then(|i| i.checked_sub(1))
        .map_or_else(|| fallback.to_owned(), |i| words[i].to_owned());
    DpiImport {
        spec,
        pure: words.contains(&"pure"),
        context: words.contains(&"context"),
        ident,
    }
}

/// The scope a loop entry's full name is built from: the array's parent, since
/// an entry `g[1]` sits beside its array `g`, not under it, in a full name
/// (`top.m.g[1].gl`).
fn full_of(parent_name: &str) -> String {
    parent_name.to_owned()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn elements_run_from_the_left_bound_to_the_right_one() {
        let down = ConstantRange { left: 2, right: 0 };
        assert_eq!(
            (0..3).map(|i| element_index(down, i)).collect::<Vec<_>>(),
            [2, 1, 0]
        );
        let up = ConstantRange { left: 1, right: 3 };
        assert_eq!(
            (0..3).map(|i| element_index(up, i)).collect::<Vec<_>>(),
            [1, 2, 3]
        );
        let single = ConstantRange { left: 5, right: 5 };
        assert_eq!(element_index(single, 0), 5);
    }

    #[test]
    fn default_net_types_map_to_the_header_constants() {
        assert_eq!(def_net_type(NetKind::Wire), Ok(consts::VPI_WIRE));
        assert_eq!(def_net_type(NetKind::WAnd), Ok(consts::VPI_WAND));
        assert_eq!(def_net_type(NetKind::Unknown), Ok(consts::VPI_NONE));
        assert!(def_net_type(NetKind::UserDefined).is_err());
    }

    /// T24 (39.3): every assertion kind becomes an object under its scope;
    /// a label names it (under any enclosing named block), an unlabeled one
    /// has no name, and each instance has its own copy.
    #[test]
    fn assertions_are_named_by_label_scoped_by_block_and_typed() {
        let session = sv_lang::Session::new();
        let mut comp = sv_lang::Compilation::new(&session).expect("compilation created");
        comp.add_source(
            "module sub(input logic clk, input logic a);\n\
             pa: assert property (@(posedge clk) a);\n\
             cover property (@(posedge clk) a);\n\
             endmodule\n\
             module top;\n\
             logic clk, a;\n\
             sub u1(clk, a);\n\
             as1: assume property (@(posedge clk) a);\n\
             rs: restrict property (@(posedge clk) a);\n\
             cs: cover sequence (@(posedge clk) a ##1 a);\n\
             initial begin\n\
             ia: assert (a);\n\
             assert #0 (a);\n\
             ic: cover final (a);\n\
             end\n\
             always @(posedge clk) begin : blk\n\
             r1: assert (a) else $error(\"a low\");\n\
             assume (a);\n\
             end\n\
             endmodule\n",
        )
        .expect("source added");
        let mut design = comp.compile().expect("design compiled");
        let m = build_model(&mut design, "t.sv").expect("model built");
        let found: Vec<(String, &str, i32, bool, bool)> = m
            .objects()
            .filter(|(_, o)| o.kind.is_assertion())
            .map(|(_, o)| {
                (
                    o.full_name.clone(),
                    o.kind.type_name(),
                    o.props.line,
                    o.props.deferred,
                    o.props.final_,
                )
            })
            .collect();
        let s = |n: &str| n.to_owned();
        assert_eq!(
            found,
            [
                (s("top.u1.pa"), "vpiAssert", 2, false, false),
                (s(""), "vpiCover", 3, false, false),
                (s("top.as1"), "vpiAssume", 8, false, false),
                (s("top.rs"), "vpiRestrict", 9, false, false),
                (s("top.cs"), "vpiCover", 10, false, false),
                (s("top.ia"), "vpiImmediateAssert", 12, false, false),
                (s(""), "vpiImmediateAssert", 13, true, false),
                (s("top.ic"), "vpiImmediateCover", 14, true, true),
                (s("top.blk.r1"), "vpiImmediateAssert", 17, false, false),
                (s(""), "vpiImmediateAssume", 18, false, false),
            ]
        );
        // Named ones are found by name, unnamed ones are not (39.3.1).
        assert!(m.find("top.blk.r1").is_some());
        assert!(m.find("").is_none());
    }

    /// The image's VPI section round-trips a model built from a real
    /// design: every object, expression node and name/signal lookup comes
    /// back identical and the bytes are deterministic.
    #[test]
    fn model_round_trips_through_its_image_section() {
        let session = sv_lang::Session::new();
        let mut comp = sv_lang::Compilation::new(&session).expect("compilation created");
        comp.add_source(
            "module sub #(parameter int W = 4, parameter string S = \"hi\", parameter real R = 1.5)\n\
             (input logic clk, input logic [W-1:0] a, output logic [W-1:0] q);\n\
             logic [7:0] mem [0:3];\n\
             int unsigned cnt;\n\
             always @(posedge clk) begin q <= a + 1; mem[a[1:0]] <= a[3:0] ^ 8'h5a; end\n\
             assign cnt = mem[1] + (a > 2 ? 3 : 4);\n\
             function automatic int f(int x); return x * 2 + 1; endfunction\n\
             pa: assert property (@(posedge clk) a != 0);\n\
             endmodule\n\
             module top;\n\
             logic clk; logic [3:0] a, q;\n\
             sub #(.W(4)) u1(clk, a, q);\n\
             sub #(.W(4), .S(\"yo\")) u2(clk, a, q);\n\
             initial begin $display(\"%0d\", u1.f(3)); end\n\
             endmodule\n",
        )
        .expect("source added");
        let mut design = comp.compile().expect("design compiled");
        let m = build_model(&mut design, "t.sv").expect("model built");
        assert!(m.len() > 20 && m.expr_count() > 3, "a non-trivial model");
        let bytes = m.encode();
        assert_eq!(bytes, m.encode(), "encoding is deterministic");
        let back = VpiModel::decode(&bytes).expect("section decodes");
        assert_eq!(back.len(), m.len());
        assert_eq!(back.expr_count(), m.expr_count());
        for (id, o) in m.objects() {
            let b = back.get(id).expect("object present");
            assert_eq!(format!("{o:?}"), format!("{b:?}"), "object {id}");
            assert_eq!(m.children(id), back.children(id), "children of {id}");
            assert_eq!(
                back.find(&o.full_name).is_some(),
                m.find(&o.full_name).is_some()
            );
        }
        for i in 0..m.expr_count() as ExprId {
            assert_eq!(
                format!("{:?}", m.expr(i)),
                format!("{:?}", back.expr(i)),
                "expr {i}"
            );
        }
        assert_eq!(m.tops(), back.tops());
        assert_eq!(m.packages(), back.packages());
        assert_eq!(m.find("top.u2"), back.find("top.u2"));
        assert_eq!(
            back.encode(),
            bytes,
            "re-encoding the decoded model is stable"
        );
        assert!(VpiModel::decode(&bytes[..bytes.len() / 2]).is_err());
    }

    /// A formal default that merely contains a sized literal is an
    /// expression, not a constant: it stays loud (37.57).
    #[test]
    fn formal_default_requires_a_whole_literal() {
        assert!(matches!(
            formal_default_node("a + 4'd1"),
            ExprNode::Unsupported(_)
        ));
        assert!(matches!(
            formal_default_node("4'd1"),
            ExprNode::Const { .. }
        ));
        assert!(matches!(formal_default_node("'1"), ExprNode::Const { .. }));
    }
}