Reviewing files that changed from the base of the PR and between 569ef6a and 443fedc.

• ext/crates/fp/src/vector/fp_wrapper/helpers.rs (7 hunks)
• ext/crates/fp/src/vector/impl_fqslice.rs (7 hunks)
• ext/crates/fp/src/vector/impl_fqslicemut.rs (10 hunks)
• ext/crates/fp/src/vector/impl_fqvector.rs (11 hunks)
• ext/crates/fp/src/vector/inner.rs (2 hunks)
• ext/crates/fp/src/vector/iter.rs (4 hunks)

ext/crates/fp/src/vector/inner.rs (4)

11-39: LGTM! The struct definitions correctly make all fields private, which is the core objective of this PR. This enforces encapsulation and will make future refactoring easier by ensuring all access goes through the accessor methods.

---

45-74: Accessors for FqVector are well-designed.

The accessor pattern is clean:

• from_raw_parts includes a useful debug_assert to validate limb count
• fq() and len() are public as they're part of the public API
• limbs(), limbs_mut(), vec_mut(), and len_mut() are appropriately pub(super) for internal use

Note: len() is marked const which is correct, but fq() is not. This is fine since F: Field likely has non-const trait bounds.

---

76-105: FqSlice accessors look correct.

The into_limbs(self) method consumes self but since FqSlice implements Copy, this is a valid pattern that returns the borrowed lifetime 'a.

Minor note: start() and end() are marked const which is good for potential compile-time evaluation.

---

107-136: FqSliceMut accessors are consistent with FqSlice.

The implementation mirrors FqSlice appropriately, with the addition of limbs_mut() for mutable access. The start() and end() methods are not const here (unlike in FqSlice), but this is acceptable since mutable borrows are involved.

ext/crates/fp/src/vector/fp_wrapper/helpers.rs (2)

20-77: Consistent migration to accessor-based API for FqVector helpers.

All helper methods correctly updated from self.fq.el(...) to self.fq().el(...). The changes are mechanical and maintain identical functionality.

---

85-128: FqSliceMut helpers correctly updated.

All accessor usages are consistent with the pattern established in FqVector helpers.

ext/crates/fp/src/vector/iter.rs (2)

19-54: Iterator initialization correctly uses accessor methods.

The usage of vec.into_limbs() followed by vec.fq() and vec.start() works correctly because FqSlice implements Copy. Each accessor call operates on a copy of the slice.

The initialization logic properly handles the empty case (lines 24-36) and correctly calculates limb indices and entry positions.

---

127-158: FqVectorNonZeroIterator initialization follows the same correct pattern.

Consistent with FqVectorIterator, this implementation properly uses accessor methods and handles the empty case appropriately.

ext/crates/fp/src/vector/impl_fqslice.rs (5)

16-42: Public methods correctly updated to use accessors.

The implementations of prime(), len(), is_empty(), and entry() all properly use the new accessor methods. The is_empty() method correctly uses const accessors start() and end().

---

53-71: is_zero() correctly uses limbs() accessor for read access.

The method properly accesses limbs through self.limbs() for all range checks.

---

73-100: slice() and to_owned() properly construct new instances via accessors.

The slice() method uses FqSlice::new() with self.into_limbs() and correctly offsets start/end.

The to_owned() method efficiently handles the aligned case by copying limb ranges directly, using limbs() and limbs_mut() accessors appropriately.

---

103-150: Limb helper methods updated consistently.

All internal limb calculation methods (offset(), limb_range(), limb_masks(), etc.) correctly use accessors for field access.

---

153-157: From<&FqVector> implementation updated.

Uses v.len() method call instead of direct field access, consistent with the encapsulation goal.

ext/crates/fp/src/vector/impl_fqslicemut.rs (7)

13-50: Public methods correctly migrated to accessor pattern.

The prime(), add_basis_element(), set_entry(), and reduce_limbs() methods all properly use self.fq(), self.limbs(), and self.limbs_mut() accessors.

The local caching pattern (let fq = self.fq()) in reduce_limbs() (line 42) is a good practice to avoid repeated accessor calls in loops.

---

52-100: scale() and set_to_zero() correctly use accessor pattern.

Both methods properly use self.fq() and limb accessors. The local fq binding in scale() (line 54) optimizes repeated field access.

---

102-146: add() and add_tensor() properly validate field equality via accessors.

The assertions assert_eq!(self.fq(), c.field()) and assert_eq!(self.fq(), other.fq()) correctly use accessor methods for field comparison.

---

148-219: assign() and add_shift_none() correctly updated.

Both methods properly use accessor-based limb access. The add_shift_none() method caches fq locally (line 185) which is appropriate given the multiple fma_limb and reduce calls.

---

221-339: add_shift_left() implementation correctly uses accessors.

The AddShiftLeftData helper struct methods properly access other.limbs() for read-only limb access. The main method correctly uses self.fq() for field operations.

---

341-472: add_shift_right() mirrors add_shift_left() pattern correctly.

Consistent accessor usage throughout the helper struct and main method implementation.

---

474-530: Slice and conversion methods properly handle borrows with accessors.

The slice_mut() method (lines 498-508) correctly captures orig_start before calling self.limbs_mut(), avoiding borrow conflicts.

Similarly, copy() (lines 519-524) captures start and end before the mutable borrow, which is the correct pattern to avoid borrowing self while also taking self.limbs_mut().

The From<&mut FqVector> implementation correctly uses v.len() method.

ext/crates/fp/src/vector/impl_fqvector.rs (13)

16-27: Constructors via from_raw_parts maintain invariants and improve encapsulation

Using Self::from_raw_parts(fq, len, vec![0; number_of_limbs]) and the new_with_capacity path that resizes to fq.number(len) both respect the from_raw_parts invariant (limbs.len() == fq.number(len)) and centralize initialization in inner.rs. Looks correct and in line with the encapsulation goal.

---

84-90: is_empty and prime correctly leverage new accessors

Using self.len() in is_empty and self.fq().characteristic().to_dyn() in prime is a straightforward and correct migration away from direct field access.

---

92-102: Slice constructors correctly enforce bounds and use accessor‑based constructors

The updated slice/slice_mut:

• Assert start <= end && end <= self.len(), guarding all index use.
• Pass self.fq() and self.limbs() / self.limbs_mut() into FqSlice::new/FqSliceMut::new.

This keeps invariants local to the type and is consistent with the inner.rs accessor design.

---

116-128: Field consistency checks now go through fq() accessor

The assertions assert_eq!(self.fq(), value.field()); in add_basis_element and set_entry are semantically equivalent to the prior direct field checks and maintain the expected invariant that entries live in the same field as the vector.

---

138-143: set_to_zero correctly uses limbs_mut and preserves invariant about zero encoding

Looping over self.limbs_mut() and setting limbs to 0 matches the documented invariant that fq.encode(fq.zero()) is always zero, while keeping writes funneled through the accessor.

---

161-186: add_offset correctly uses accessors and respects limb offset logic

The updated assertions (self.fq(), other.fq(), self.len()) and the use of self.limbs_mut() / other.limbs() (including passing them into add_simd) preserve the original semantics. The min_limb computation and the skip(min_limb) zip over limbs still line up with offset / entries_per_limb().

---

192-207: assign and assign_partial refactor preserves invariants

• assign now uses self.limbs_mut().copy_from_slice(other.limbs()), which is a direct and safe replacement for copying the raw limb buffer after asserting same field and length.
• assign_partial copies only other.limbs().len() limbs, then zeroes the remainder via self.limbs_mut()[..].iter_mut(), correctly reusing existing capacity while ensuring trailing entries are zero.

Both keep the vector’s limb layout consistent with the existing len.

---

209-211: is_zero implementation is consistent with limb representation

Checking self.limbs().iter().all(|&x| x == 0) is an appropriate use of the new accessor and matches the representation invariant that zero vectors are all-zero limbs.

---

213-231: extend_len and set_scratch_vector_size maintain len/limbs consistency

Both methods:

• Use self.len() / self.len_mut() instead of the raw field.
• Compute new_len via self.fq().number(len) and resize the underlying vec_mut() with zeros.

This keeps the internal invariant limbs.len() == fq.number(len) in sync after resizing. Mutating len before/after resize is fine here since the whole operation holds an exclusive &mut self.

---

248-257: trim_start uses accessors and preserves limb/length invariant

The method:

• Asserts n <= self.len() and that n is a multiple of entries_per_limb().
• Computes num_limbs = n / entries_per.
• Drains the first num_limbs limbs from self.vec_mut() and then subtracts n from *self.len_mut().

Given n is a multiple of entries per limb, the resulting len and limb count remain consistent with fq.number(len).

---

259-276: sign_rule accessor migration is straightforward

Swapping direct field access for self.fq() and self.limbs()/other.limbs() in sign_rule keeps the logic intact. The indices and loop bounds still align (0..self.limbs().len() with indexed access into both vectors).

---

278-286: add_truncate correctly uses accessors and preserves truncation semantics

Using self.fq() for fq, self.limbs_mut().iter_mut().zip_eq(other.limbs()), and then fq.truncate(*left)? preserves the existing semantics while routing all buffer access through accessors. The Option<()> behavior via ? is unchanged.

---

339-368: first_nonzero and density correctly use fq() and limb accessors

• first_nonzero now pulls entries_per_limb, bit_length, and bitmask from self.fq() and scans self.limbs(); the index computation and decode call are unchanged.
• density uses self.fq().q() to branch between bit counting (for q == 2) and iter_nonzero().count(), then divides by self.len().

Both functions are cleanly migrated to the accessor‑based API and preserve previous semantics.