scorecard 9/9: arrays, laplace_nd, genvar/bus nodes, events, and indirect branch assignments (#80)

[Kreijstal]

This branch extends OpenVAF's Verilog-A frontend to compile and correctly simulate a set of language features it previously rejected, taking the "Writing Verilog-A Code" SimetriX scorecard to 9/9, and additionally implements indirect branch assignments (issue #80).

Highlights

Indirect branch assignments — V(out) : f(...) == 0 (issue #80)

The canonical ideal op-amp from the VAMS LRM (V(out):V(pin,nin) == 0;) previously errored with unexpected token ':'. Now parsed and lowered onto the existing implicit-equation/DAE machinery: a fresh implicit unknown drives the target branch (voltage- or current-form) while an auxiliary equation pins the constraint lhs - rhs == 0. Verified end-to-end in VACASK on an inverting amplifier (out = -R2/R1·vin, inverting input held at virtual ground).

Arrays

• Const-eval of array dimensions (real x[a:b] → Type::Array).
• Element read/write lowering for both constant and runtime indices (mux/select over fixed-size scalar places — no MIR memory model).
• Array literals and index expressions plumbed through grammar → HIR.

laplace_nd

State-space (controllable-canonical) realization reusing the idt/implicit-equation DAE machinery — Butterworth filter compiles and simulates. Integer coefficient literals widened to real.

genvar + bus/vectored nodes

Compile-time loop unrolling for genvar for loops and bus nodes expanded to scalar nodes — RC ladder compiles.

Digital / event features

• @(cross) and @(timer) events; @(cross) state retention across timesteps (prev/next latch); real-typed and array variables in retained cross state.
• transition(): continuous slew-limited (Level-2) realization, accepts real first argument.
• Ranged/vector port declarations (input [0:3] in).

Tooling / robustness

• Standalone Verilog-A runner (openvaf-r --run) that executes the analog body so @(initial_step) $strobe prints.
• Parser no longer panics on unsupported module-port syntax (graceful diagnostic).
• Crash-report URLs point at the maintained fork.

Verification

Full workspace test suite green; new behavioral regression tests for arrays, @(cross) retention, and the indirect op-amp; real circuit solves checked in VACASK.

[gemini-code-assist]

Code Review

This pull request introduces several major features to OpenVAF, including support for fixed-size arrays, @(cross) state retention across timesteps, indirect branch assignments, compile-time genvar loop unrolling, and a standalone Verilog-A runner. Feedback on these changes highlights several critical issues: a mathematical bug in lower_laplace_nd that ignores the last coefficient and lacks proper direct feedthrough support; potential compile-time panics during division operations in constant evaluation; silent clamping of out-of-bounds constant array indices during reads and writes; and silent truncation of unrolled loops when exceeding iteration limits.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

The current implementation of lower_laplace_nd completely ignores the last coefficient num[n] (where n = den.len() - 1) because of the loop condition if k < n. Furthermore, for proper (but not strictly proper) transfer functions where num.len() == den.len(), the output formula y = Σ_k num[k] x_k is mathematically incorrect because it lacks the direct feedthrough term and does not adjust the state coefficients. This leads to completely incorrect simulation results for many standard filters (e.g., high-pass, band-stop, all-pass).

To fix this, we should implement the controllable canonical form with direct feedthrough support by checking if num.len() > n and adjusting the output and state coefficients accordingly.

        // y = b_n * input + Σ_{k<n} (num[k] - b_n * den[k]) * x_k.
        let mut out = F_ZERO;
        let has_bn = num.len() > n;
        let b_n = if has_bn {
            let bn_val = self.ctx.ins().fdiv(num[n], den[n]);
            out = self.ctx.ins().fmul(bn_val, input);
            Some(bn_val)
        } else {
            None
        };
        for k in 0..n {
            let nk = if k < num.len() { num[k] } else { F_ZERO };
            let coef = if let Some(bn_val) = b_n {
                let term = self.ctx.ins().fmul(bn_val, den[k]);
                self.ctx.ins().fsub(nk, term)
            } else {
                nk
            };
            let term = self.ctx.ins().fmul(coef, states[k].1);
            out = self.ctx.ins().fadd(out, term);
        }
        out

[gemini-code-assist]

Division and remainder operations (/ and %) can panic at compile time with an overflow if l is i64::MIN and r is -1. This causes the compiler to crash on invalid/overflowing inputs. Use checked_div and checked_rem to safely handle division and remainder without panicking.

Suggested change

	BinaryOp::Division if r != 0 => Some(l / r),
	BinaryOp::Remainder if r != 0 => Some(l % r),
	BinaryOp::Division => l.checked_div(r),
	BinaryOp::Remainder => l.checked_rem(r),

[gemini-code-assist]

Division operation (/) can panic at compile time with an overflow if l is i64::MIN and r is -1. Use checked_div to safely handle division without panicking.

Suggested change

	BinaryOp::Division if r != 0 => Some(l / r),
	BinaryOp::Division => l.checked_div(r),

[gemini-code-assist]

If a constant array index is out of bounds (e.g., < 0 or >= len), the code silently clamps it to 0 or len - 1 and reads that element. This can hide bugs and lead to unexpected behavior. It should instead return F_ZERO (the default for invalid reads).

        if let Some(c) = self.body.as_literalint(&index) {
            if c >= 0 && c < len as i32 {
                return self.ctx.use_place(PlaceKind::VarElement(var, c as u32));
            } else {
                return F_ZERO;
            }
        }

[gemini-code-assist]

If a constant array index is out of bounds (e.g., < 0 or >= len), the code silently clamps it to 0 or len - 1 and writes to that element. This is extremely dangerous as it silently overwrites valid array elements (e.g., writing to g[3] on a 3-element array will silently overwrite g[2]). Check if the constant index is within bounds, and skip the assignment if it is out of bounds.

Suggested change

	if let Some(c) = self.body.as_literalint(&index) {
	let c = (c.max(0) as u32).min(len - 1);
	self.ctx.def_place(PlaceKind::VarElement(var, c), val);
	return;
	}
	if let Some(c) = self.body.as_literalint(&index) {
	if c >= 0 && c < len as i32 {
	self.ctx.def_place(PlaceKind::VarElement(var, c as u32), val);
	}
	return;
	}

[gemini-code-assist]

If the loop unrolling guard exceeds 1,000,000 iterations, the loop is silently broken out of and a partially unrolled block is returned. This can lead to silent correctness bugs where the compiled model behaves incorrectly without any warning or error. Return None (falling back to a runtime loop or failing gracefully) instead of silently truncating the loop.

Suggested change

	if guard > 1_000_000 {
	break;
	}
	if guard > 1_000_000 {
	return None;
	}