fix: docs warnings

crates/circuits/primitives/src/lib.rs

@@ -1,7 +1,7 @@
 //! This crate contains a collection of primitives for use when building circuits.
-//! The primitives are separated into two types: standalone [Air](p3_air::Air)s and [SubAir]s.
+//! The primitives are separated into two types: standalone [Air](openvm_stark_backend::p3_air::Air)s and [SubAir]s.
 //!
-//! The following modules contain standalone [Air]s:
+//! The following modules contain standalone [Air](openvm_stark_backend::p3_air::Air)s:
 //! - [range]
 //! - [range_gate]
 //! - [range_tuple]

crates/circuits/primitives/src/sub_air.rs

@@ -3,7 +3,7 @@ use openvm_stark_backend::p3_air::AirBuilder;
 /// Trait with associated types intended to allow re-use of constraint logic
 /// inside other AIRs.
 ///
-/// A `SubAir` is **not** an [`Air`](p3_air::Air) itself.
+/// A `SubAir` is **not** an [Air](openvm_stark_backend::p3_air::Air) itself.
 /// A `SubAir` is a struct that holds the means to generate a particular set of constraints,
 /// meant to be re-usable within other AIRs.
 ///

crates/circuits/sha256-air/src/trace.rs

@@ -42,7 +42,7 @@ impl Sha256Air {
     /// and the buffer values that will be put in rows 0..4.
     /// Will populate the given `trace` with the trace of the block, where the width of the trace is `trace_width`
     /// and the starting column for the `Sha256Air` is `trace_start_col`.
-    /// **Note**: this function only generates some of the required trace. Another pass is required, refer to [`generate_missing_cells`] for details.
+    /// **Note**: this function only generates some of the required trace. Another pass is required, refer to [`Self::generate_missing_cells`] for details.
     #[allow(clippy::too_many_arguments)]
     pub fn generate_block_trace<F: PrimeField32>(
         &self,
@@ -285,7 +285,7 @@ impl Sha256Air {
 
     /// This function will fill in the cells that we couldn't do during the first pass.
     /// This function should be called only after `generate_block_trace` was called for all blocks
-    /// And [`generate_default_row`] is called for all invalid rows
+    /// And [`Self::generate_default_row`] is called for all invalid rows
     /// Will populate the missing values of `trace`, where the width of the trace is `trace_width`
     /// and the starting column for the `Sha256Air` is `trace_start_col`.
     /// Note: `trace` needs to be the rows 1..17 of a block and the first row of the next block

crates/sdk/src/commit.rs

@@ -35,7 +35,7 @@ pub struct AppExecutionCommit<T> {
     ///     ),
     ///     hash(right_pad(pc_start, 0))
     /// )
-    /// `right_pad` example, if pc_start = 123, right_pad(pc_start, 0) = [123,0,0,0,0,0,0,0]
+    /// `right_pad` example, if pc_start = 123, right_pad(pc_start, 0) = \[123,0,0,0,0,0,0,0\]
     pub exe_commit: [T; DIGEST_SIZE],
 }
 

crates/sdk/src/verifier/root/types.rs

@@ -25,7 +25,7 @@ pub struct RootVmVerifierPvs<T> {
 
 /// Input for the root VM verifier.
 /// Note: Root verifier is proven in Root SC, but it usually verifies proofs in SC. So
-/// usually only RootVmVerifierInput<SC> is needed.
+/// usually only RootVmVerifierInput\<SC\> is needed.
 #[derive(Serialize, Deserialize, Derivative)]
 #[serde(bound = "")]
 #[derivative(Clone(bound = "Com<SC>: Clone"))]

crates/toolchain/transpiler/src/extension.rs

@@ -3,10 +3,10 @@ use openvm_instructions::instruction::Instruction;
 /// Trait to add custom RISC-V instruction transpilation to OpenVM instruction format.
 /// RISC-V instructions always come in 32-bit chunks.
 /// An important feature is that multiple 32-bit RISC-V instructions can be transpiled into a single OpenVM instruction.
-/// See `process_custom` for details.
+/// See [process_custom](Self::process_custom) for details.
 pub trait TranspilerExtension<F> {
     /// The `instruction_stream` provides a view of the remaining RISC-V instructions to be processed,
-    /// presented as 32-bit chunks. The [`CustomInstructionProcessor`] should determine if it knows how to transpile
+    /// presented as 32-bit chunks. The [process_custom](Self::process_custom) should determine if it knows how to transpile
     /// the next contiguous section of RISC-V instructions into an [`Instruction`].
     /// It returns `None` if it cannot transpile. Otherwise it returns `(instruction, how_many_u32s)` to indicate that
     /// `instruction_stream[..how_many_u32s]` should be transpiled into `instruction`.

crates/vm/src/arch/execution.rs

@@ -287,7 +287,7 @@ impl<T: FieldAlgebra> From<(u32, Option<T>)> for PcIncOrSet<T> {
 }
 
 /// Phantom sub-instructions affect the runtime of the VM and the trace matrix values.
-/// However they all have no AIR constraints besides advancing the pc by [DEFAULT_PC_STEP](super::program::DEFAULT_PC_STEP).
+/// However they all have no AIR constraints besides advancing the pc by [DEFAULT_PC_STEP](openvm_instructions::program::DEFAULT_PC_STEP).
 ///
 /// They should not mutate memory, but they can mutate the input & hint streams.
 ///

crates/vm/src/arch/integration_api.rs

@@ -94,7 +94,7 @@ pub trait VmAdapterChip<F> {
 pub trait VmAdapterAir<AB: AirBuilder>: BaseAir<AB::F> {
     type Interface: VmAdapterInterface<AB::Expr>;
 
-    /// [Air](p3_air::Air) constraints owned by the adapter.
+    /// [Air](openvm_stark_backend::p3_air::Air) constraints owned by the adapter.
     /// The `interface` is given as abstract expressions so it can be directly used in other AIR constraints.
     ///
     /// Adapters should document the max constraint degree as a function of the constraint degrees of `reads, writes, instruction`.

crates/vm/src/arch/testing/memory/mod.rs

@@ -40,7 +40,7 @@ impl<F: PrimeField32> MemoryTester<F> {
         }
     }
 
-    /// Returns the cell value at the current timestamp according to [MemoryController].
+    /// Returns the cell value at the current timestamp according to `MemoryController`.
     pub fn read_cell(&mut self, address_space: usize, pointer: usize) -> F {
         let [addr_space, pointer] = [address_space, pointer].map(F::from_canonical_usize);
         // core::BorrowMut confuses compiler

crates/vm/src/system/memory/offline_checker/bridge.rs

@@ -115,7 +115,7 @@ pub struct MemoryReadOperation<'a, T, V, const N: usize> {
 
 /// The max degree of constraints is:
 /// eval_timestamps: deg(enabled) + max(1, deg(self.timestamp))
-/// eval_bulk_access: refer to [MemoryOfflineChecker::eval_bulk_access]
+/// eval_bulk_access: refer to private function MemoryOfflineChecker::eval_bulk_access
 impl<F: FieldAlgebra, V: Copy + Into<F>, const N: usize> MemoryReadOperation<'_, F, V, N> {
     /// Evaluate constraints and send/receive interactions.
     pub fn eval<AB>(self, builder: &mut AB, enabled: impl Into<AB::Expr>)
@@ -169,7 +169,7 @@ pub struct MemoryReadOrImmediateOperation<'a, T, V> {
 ///                           deg(address.address_space) + deg(aux.is_zero_aux))
 /// is_immediate check: deg(aux.is_immediate) + max(deg(data), deg(address.pointer))
 /// eval_timestamps: deg(enabled) + max(1, deg(self.timestamp))
-/// eval_bulk_access: refer to [MemoryOfflineChecker::eval_bulk_access]
+/// eval_bulk_access: refer to private function MemoryOfflineChecker::eval_bulk_access
 impl<F: FieldAlgebra, V: Copy + Into<F>> MemoryReadOrImmediateOperation<'_, F, V> {
     /// Evaluate constraints and send/receive interactions.
     pub fn eval<AB>(self, builder: &mut AB, enabled: impl Into<AB::Expr>)
@@ -229,7 +229,7 @@ pub struct MemoryWriteOperation<'a, T, V, const N: usize> {
 
 /// The max degree of constraints is:
 /// eval_timestamps: deg(enabled) + max(1, deg(self.timestamp))
-/// eval_bulk_access: refer to [MemoryOfflineChecker::eval_bulk_access]
+/// eval_bulk_access: refer to private function MemoryOfflineChecker::eval_bulk_access
 impl<T: FieldAlgebra, V: Copy + Into<T>, const N: usize> MemoryWriteOperation<'_, T, V, N> {
     /// Evaluate constraints and send/receive interactions. `enabled` must be boolean.
     pub fn eval<AB>(self, builder: &mut AB, enabled: impl Into<AB::Expr>)

crates/vm/src/system/memory/offline_checker/columns.rs

@@ -22,7 +22,7 @@ pub struct MemoryBaseAuxCols<T> {
 }
 
 impl<T: Clone> MemoryBaseAuxCols<T> {
-    /// TODO[arayi]: Since we have AlignedBorrow, should remove all from_slice, from_iterator, and flatten in a future PR.
+    // TODO[arayi]: Since we have AlignedBorrow, should remove all from_slice, from_iterator, and flatten in a future PR.
     pub fn from_slice(slc: &[T]) -> Self {
         let base_aux_cols: &MemoryBaseAuxCols<T> = slc.borrow();
         base_aux_cols.clone()

crates/vm/src/system/poseidon2/mod.rs

@@ -1,5 +1,5 @@
 //! Chip to handle **native kernel** instructions for Poseidon2 `compress` and `permute`.
-//! This chip is put in [intrinsics](crate::intrinsics) for organizational convenience, but
+//! This chip is put in `intrinsics` for organizational convenience, but
 //! it is used as a system chip for persistent memory and as a native kernel chip for aggregation.
 //!
 //! Note that neither `compress` nor `permute` on its own

extensions/keccak256/circuit/src/air.rs

@@ -164,7 +164,7 @@ impl KeccakVmAir {
     }
 
     /// Keccak follows the 10*1 padding rule.
-    /// See Section 5.1 of https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf
+    /// See Section 5.1 of <https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf>
     /// Note this is the ONLY difference between Keccak and SHA-3
     ///
     /// Constrains padding constraints and length between rounds and

extensions/keccak256/circuit/src/columns.rs

@@ -37,7 +37,7 @@ pub struct KeccakInstructionCols<T> {
     /// False on dummy rows only used to pad the height.
     pub is_enabled: T,
     /// Is enabled and first round of block. Used to lower constraint degree.
-    /// is_enabled * inner.step_flags[0]
+    /// is_enabled * inner.step_flags\[0\]
     pub is_enabled_first_round: T,
     /// The starting timestamp to use for memory access in this row.
     /// A single row will do multiple memory accesses.
@@ -51,17 +51,17 @@ pub struct KeccakInstructionCols<T> {
     /// Memory address space
     pub e: T,
     // Register values
-    /// dst <- [dst_ptr:4]_1
+    /// dst <- \[dst_ptr:4\]_1
     pub dst: [T; RV32_REGISTER_NUM_LIMBS],
-    /// src <- [src_ptr:4]_1
-    /// We store src_limbs[i] = [src_ptr + i + 1]_1 and src = u32([src_ptr:4]_1) from which [src_ptr]_1
+    /// src <- \[src_ptr:4\]_1
+    /// We store src_limbs\[i\] = \[src_ptr + i + 1\]_1 and src = u32(\[src_ptr:4\]_1) from which \[src_ptr\]_1
     /// can be recovered by linear combination.
     /// We do this because `src` needs to be incremented between keccak-f permutations.
     pub src_limbs: [T; RV32_REGISTER_NUM_LIMBS - 1],
     pub src: T,
-    /// len <- [len_ptr:4]_1
-    /// We store len_limbs[i] = [len_ptr + i + 1]_1 and remaining_len = u32([len_ptr:4]_1)
-    /// from which [len_ptr]_1 can be recovered by linear combination.
+    /// len <- \[len_ptr:4\]_1
+    /// We store len_limbs\[i\] = \[len_ptr + i + 1\]_1 and remaining_len = u32(\[len_ptr:4\]_1)
+    /// from which \[len_ptr\]_1 can be recovered by linear combination.
     /// We do this because `remaining_len` needs to be decremented between keccak-f permutations.
     pub len_limbs: [T; RV32_REGISTER_NUM_LIMBS - 1],
     /// The remaining length of the unpadded input, in bytes.
@@ -99,8 +99,8 @@ pub struct KeccakMemoryCols<T> {
     pub register_aux: [MemoryReadAuxCols<T, RV32_REGISTER_NUM_LIMBS>; KECCAK_REGISTER_READS],
     pub absorb_reads: [MemoryReadAuxCols<T, KECCAK_WORD_SIZE>; KECCAK_ABSORB_READS],
     pub digest_writes: [MemoryWriteAuxCols<T, KECCAK_WORD_SIZE>; KECCAK_DIGEST_WRITES],
-    /// The input bytes are batch read in blocks of [KECCAK_WORD_SIZE] bytes. However
-    /// if the input length is not a multiple of [KECCAK_WORD_SIZE], we read into
+    /// The input bytes are batch read in blocks of private constant KECCAK_WORD_SIZE bytes. However
+    /// if the input length is not a multiple of KECCAK_WORD_SIZE, we read into
     /// `partial_block` more bytes than we need. On the other hand `block_bytes` expects
     /// only the partial block of bytes and then the correctly padded bytes.
     /// We will select between `partial_block` and `block_bytes` for what to read from memory.

extensions/native/compiler/src/ir/bits.rs

@@ -120,10 +120,10 @@ impl<C: Config> Builder<C> {
 
     /// Reverse a list of bits.
     ///
-    /// SAFETY: calling this function with `bit_len` greater [`NUM_BITS`] will result in undefined
+    /// SAFETY: calling this function with `bit_len` greater `NUM_BITS` will result in undefined
     /// behavior.
     ///
-    /// Reference: [p3_util::reverse_bits_len]
+    /// Reference: [`openvm_stark_backend::p3_util`]
     pub fn reverse_bits_len(
         &mut self,
         index_bits: &Array<C, Var<C::N>>,
@@ -149,10 +149,10 @@ impl<C: Config> Builder<C> {
 
     /// Reverse a list of bits inside a circuit.
     ///
-    /// SAFETY: calling this function with `bit_len` greater [`NUM_BITS`] will result in undefined
+    /// SAFETY: calling this function with `bit_len` greater `NUM_BITS` will result in undefined
     /// behavior.
     ///
-    /// Reference: [p3_util::reverse_bits_len]
+    /// Reference: [`openvm_stark_backend::p3_util`]
     pub fn reverse_bits_len_circuit(
         &mut self,
         index_bits: Vec<Var<C::N>>,

extensions/native/compiler/src/ir/poseidon.rs

@@ -9,7 +9,7 @@ pub const PERMUTATION_WIDTH: usize = 16;
 impl<C: Config> Builder<C> {
     /// Applies the Poseidon2 permutation to the given array.
     ///
-    /// Reference: [p3_poseidon2::Poseidon2]
+    /// [Reference](https://docs.rs/p3-poseidon2/latest/p3_poseidon2/struct.Poseidon2.html)
     pub fn poseidon2_permute(&mut self, array: &Array<C, Felt<C::F>>) -> Array<C, Felt<C::F>> {
         let output = match array {
             Array::Fixed(values) => {
@@ -27,7 +27,7 @@ impl<C: Config> Builder<C> {
 
     /// Applies the Poseidon2 permutation to the given array.
     ///
-    /// Reference: [p3_poseidon2::Poseidon2]
+    /// [Reference](https://docs.rs/p3-poseidon2/latest/p3_poseidon2/struct.Poseidon2.html)
     pub fn poseidon2_permute_mut(&mut self, array: &Array<C, Felt<C::F>>) {
         if let Array::Fixed(_) = array {
             panic!("Poseidon2 permutation is not allowed on fixed arrays");
@@ -40,7 +40,7 @@ impl<C: Config> Builder<C> {
 
     /// Applies the Poseidon2 compression function to the given array.
     ///
-    /// Reference: [p3_symmetric::TruncatedPermutation]
+    /// [Reference](https://docs.rs/p3-symmetric/latest/p3_symmetric/struct.TruncatedPermutation.html)
     pub fn poseidon2_compress(
         &mut self,
         left: &Array<C, Felt<C::F>>,
@@ -60,7 +60,7 @@ impl<C: Config> Builder<C> {
 
     /// Applies the Poseidon2 compression to the given array.
     ///
-    /// Reference: [p3_symmetric::TruncatedPermutation]
+    /// [Reference](https://docs.rs/p3-symmetric/latest/p3_symmetric/struct.TruncatedPermutation.html)
     pub fn poseidon2_compress_x(
         &mut self,
         result: &Array<C, Felt<C::F>>,
@@ -76,7 +76,7 @@ impl<C: Config> Builder<C> {
 
     /// Applies the Poseidon2 permutation to the given array.
     ///
-    /// Reference: [p3_symmetric::PaddingFreeSponge]
+    /// [Reference](https://docs.rs/p3-symmetric/latest/p3_symmetric/struct.PaddingFreeSponge.html)
     pub fn poseidon2_hash(&mut self, array: &Array<C, Felt<C::F>>) -> Array<C, Felt<C::F>> {
         let perm_width = PERMUTATION_WIDTH;
         let state: Array<C, Felt<C::F>> = self.dyn_array(perm_width);

extensions/native/compiler/src/ir/utils.rs

@@ -23,7 +23,7 @@ pub fn prime_field_to_usize<F: PrimeField>(x: F) -> usize {
 impl<C: Config> Builder<C> {
     /// The generator for the field.
     ///
-    /// Reference: [p3_baby_bear::BabyBear]
+    /// Reference: [`openvm_stark_sdk::p3_baby_bear::BabyBear`]
     pub fn generator(&mut self) -> Felt<C::F> {
         self.eval(C::F::from_canonical_u32(31))
     }
@@ -141,7 +141,7 @@ impl<C: Config> Builder<C> {
 
     /// Exponentiates a variable to a list of reversed bits with a given length.
     ///
-    /// Reference: [p3_util::reverse_bits_len]
+    /// Reference: [`openvm_stark_backend::p3_util::reverse_bits_len`]
     pub fn exp_reverse_bits_len<V>(
         &mut self,
         x: V,

extensions/native/recursion/src/challenger/duplex.rs

@@ -12,7 +12,7 @@ use crate::{
     digest::DigestVariable,
 };
 
-/// Reference: [p3_challenger::DuplexChallenger]
+/// Reference: [`openvm_stark_backend::p3_challenger::DuplexChallenger`]
 #[derive(Clone)]
 pub struct DuplexChallengerVariable<C: Config> {
     pub sponge_state: Array<C, Felt<C::F>>,

extensions/native/recursion/src/challenger/mod.rs

@@ -8,14 +8,14 @@ use crate::digest::DigestVariable;
 pub mod duplex;
 pub mod multi_field32;
 
-/// Reference: [p3_challenger::CanObserve].
+/// Reference: [`openvm_stark_backend::p3_challenger::CanObserve`]
 pub trait CanObserveVariable<C: Config, V> {
     fn observe(&mut self, builder: &mut Builder<C>, value: V);
 
     fn observe_slice(&mut self, builder: &mut Builder<C>, values: Array<C, V>);
 }
 
-/// Reference: [p3_challenger::CanObserve].
+/// Reference: [`openvm_stark_backend::p3_challenger::CanObserve`]
 pub trait CanObserveDigest<C: Config> {
     fn observe_digest(&mut self, builder: &mut Builder<C>, value: DigestVariable<C>);
 }
@@ -25,7 +25,7 @@ pub trait CanSampleVariable<C: Config, V> {
     fn sample(&mut self, builder: &mut Builder<C>) -> V;
 }
 
-/// Reference: [p3_challenger::FieldChallenger].
+/// Reference: [`openvm_stark_backend::p3_challenger::FieldChallenger`]
 pub trait FeltChallenger<C: Config>:
     CanObserveVariable<C, Felt<C::F>> + CanSampleVariable<C, Felt<C::F>> + CanSampleBitsVariable<C>
 {

extensions/native/recursion/src/fri/domain.rs

@@ -7,7 +7,7 @@ use openvm_stark_backend::{
 use super::types::FriConfigVariable;
 use crate::commit::PolynomialSpaceVariable;
 
-/// Reference: [p3_commit::TwoAdicMultiplicativeCoset]
+/// Reference: [`openvm_stark_backend::p3_commit::TwoAdicMultiplicativeCoset`]
 #[derive(DslVariable, Clone)]
 pub struct TwoAdicMultiplicativeCosetVariable<C: Config> {
     pub log_n: Usize<C::N>,

extensions/native/recursion/src/fri/mod.rs

@@ -27,7 +27,7 @@ pub mod witness;
 ///
 /// Currently assumes the index that is accessed is constant.
 ///
-/// Reference: https://github.com/Plonky3/Plonky3/blob/4809fa7bedd9ba8f6f5d3267b1592618e3776c57/fri/src/verifier.rs#L101
+/// Reference: <https://github.com/Plonky3/Plonky3/blob/4809fa7bedd9ba8f6f5d3267b1592618e3776c57/fri/src/verifier.rs#L101>
 #[allow(clippy::too_many_arguments)]
 #[allow(unused_variables)]
 pub fn verify_query<C: Config>(
@@ -138,7 +138,7 @@ pub enum NestedOpenedValues<C: Config> {
 ///
 /// Assumes the dimensions have already been sorted by tallest first.
 ///
-/// Reference: https://github.com/Plonky3/Plonky3/blob/4809fa7bedd9ba8f6f5d3267b1592618e3776c57/merkle-tree/src/mmcs.rs#L92
+/// Reference: <https://github.com/Plonky3/Plonky3/blob/4809fa7bedd9ba8f6f5d3267b1592618e3776c57/merkle-tree/src/mmcs.rs#L92>
 #[allow(clippy::type_complexity)]
 #[allow(unused_variables)]
 pub fn verify_batch<C: Config>(
@@ -255,7 +255,7 @@ pub fn verify_batch<C: Config>(
 ///
 /// Assumes the dimensions have already been sorted by tallest first.
 ///
-/// Reference: https://github.com/Plonky3/Plonky3/blob/4809fa7bedd9ba8f6f5d3267b1592618e3776c57/merkle-tree/src/mmcs.rs#L92
+/// Reference: <https://github.com/Plonky3/Plonky3/blob/4809fa7bedd9ba8f6f5d3267b1592618e3776c57/merkle-tree/src/mmcs.rs#L92>
 #[allow(clippy::type_complexity)]
 #[allow(unused_variables)]
 pub fn verify_batch_static<C: Config>(

extensions/native/recursion/src/halo2/utils.rs

@@ -149,7 +149,7 @@ fn read_params(k: u32) -> Arc<Halo2Params> {
 /// Sort AIRs by their trace height in descending order. This should not be used outside
 /// static-verifier because a dynamic verifier should support any AIR order.
 /// This is related to an implementation detail of FieldMerkleTreeMMCS which is used in most configs.
-/// Reference: https://github.com/Plonky3/Plonky3/blob/27b3127dab047e07145c38143379edec2960b3e1/merkle-tree/src/merkle_tree.rs#L53
+/// Reference: <https://github.com/Plonky3/Plonky3/blob/27b3127dab047e07145c38143379edec2960b3e1/merkle-tree/src/merkle_tree.rs#L53>
 pub fn sort_chips<SC: StarkGenericConfig>(
     mut air_proof_inputs: Vec<AirProofInput<SC>>,
 ) -> Vec<AirProofInput<SC>> {

extensions/native/recursion/src/stark/mod.rs

@@ -48,7 +48,7 @@ pub struct VerifierProgram<C: Config> {
 }
 
 impl VerifierProgram<InnerConfig> {
-    /// Create a new instance of the program for the [BabyBearPoseidon2] config.
+    /// Create a new instance of the program for the [`openvm_stark_sdk::config::baby_bear_poseidon2`]
     pub fn build(
         constants: MultiStarkVerificationAdvice<InnerConfig>,
         fri_params: &FriParameters,
@@ -60,7 +60,7 @@ impl VerifierProgram<InnerConfig> {
         Self::build_with_options(constants, fri_params, options)
     }
 
-    /// Create a new instance of the program for the [BabyBearPoseidon2] config.
+    /// Create a new instance of the program for the [`openvm_stark_sdk::config::baby_bear_poseidon2`]
     pub fn build_with_options(
         constants: MultiStarkVerificationAdvice<InnerConfig>,
         fri_params: &FriParameters,