Merge pull request #3257 from ProvableHQ/mohammadfawaz/rename_query_to_view

refactor: rename `query` to `view`

Author: vicsn

.circleci/config.yml

@@ -905,8 +905,8 @@ jobs:
     steps:
       - run_test:
           workspace_member: snarkvm-synthesizer
-          # `history` enables the per-key historical update map that the `query` evaluation path
-          # depends on; gating it here ensures the v15 query tests are exercised in CI.
+          # `history` enables the per-key historical update map that the `view` evaluation path
+          # depends on; gating it here ensures the v15 view tests are exercised in CI.
           flags: >
             --lib --bins --features test,history
             --partition count:1/2

console/network/src/lib.rs

@@ -226,8 +226,8 @@ pub trait Network:
     const MAX_RECORDS: usize = 10 * Self::MAX_FUNCTIONS;
     /// The maximum number of closures in a program.
     const MAX_CLOSURES: usize = 2 * Self::MAX_FUNCTIONS;
-    /// The maximum number of query functions in a program.
-    const MAX_QUERIES: usize = 2 * Self::MAX_FUNCTIONS;
+    /// The maximum number of view functions in a program.
+    const MAX_VIEWS: usize = 2 * Self::MAX_FUNCTIONS;
     /// The maximum number of operands in an instruction.
     const MAX_OPERANDS: usize = Self::MAX_INPUTS;
     /// The maximum number of instructions in a closure or function.

synthesizer/process/src/cost.rs

@@ -259,16 +259,16 @@ pub fn deployment_cost_v2<N: Network>(
         );
     }
 
-    // Bound each query function's worst-case compute. Queries are off-consensus and have no
+    // Bound each view function's worst-case compute. Views are off-consensus and have no
     // dedicated fee component beyond what is already counted in `storage_cost` (their bytes
     // contribute to `size_in_bytes`). The bound below is purely a deploy-time sanity check
-    // to keep pathological queries from being accepted.
-    for query in deployment.program().queries().values() {
-        let query_cost = query_cost_for_single_query(&stack, query.name(), ConsensusFeeVersion::V3)?;
+    // to keep pathological views from being accepted.
+    for view in deployment.program().views().values() {
+        let view_cost = view_cost_for_single_view(&stack, view.name(), ConsensusFeeVersion::V3)?;
         ensure!(
-            query_cost <= N::TRANSACTION_SPEND_LIMIT[1].1,
-            "Query '{}' has a cost '{query_cost}' which exceeds the transaction spend limit '{}'",
-            query.name(),
+            view_cost <= N::TRANSACTION_SPEND_LIMIT[1].1,
+            "View '{}' has a cost '{view_cost}' which exceeds the transaction spend limit '{}'",
+            view.name(),
             N::TRANSACTION_SPEND_LIMIT[1].1
         );
     }
@@ -1014,28 +1014,28 @@ fn finalize_cost_for_single_function_raw<N: Network>(
     Ok(finalize_cost)
 }
 
-/// Returns the maximum compute cost (in microcredits) of a single query function's body.
+/// Returns the maximum compute cost (in microcredits) of a single view function's body.
 ///
-/// Queries do not run as part of consensus, so this cost is not paid by anyone — it is only
+/// Views do not run as part of consensus, so this cost is not paid by anyone — it is only
 /// used as a deploy-time sanity bound (mirrors the per-function `TRANSACTION_SPEND_LIMIT`
-/// check) to prevent deploying queries whose worst-case compute is unreasonable.
-fn query_cost_for_single_query<N: Network>(
+/// check) to prevent deploying views whose worst-case compute is unreasonable.
+fn view_cost_for_single_view<N: Network>(
     stack: &Stack<N>,
-    query_name: &Identifier<N>,
+    view_name: &Identifier<N>,
     consensus_fee_version: ConsensusFeeVersion,
 ) -> Result<u64> {
-    let query = stack.program().get_query_ref(query_name)?;
+    let view = stack.program().get_view_ref(view_name)?;
 
-    // Query types are not cached on the stack today; recompute them here for the cost walk.
-    let query_types = FinalizeTypes::from_query(stack, query)?;
+    // View types are not cached on the stack today; recompute them here for the cost walk.
+    let view_types = FinalizeTypes::from_view(stack, view)?;
 
-    let mut query_cost = 0u64;
-    for command in query.commands() {
-        query_cost = query_cost
-            .checked_add(cost_per_command(stack, &query_types, command, consensus_fee_version)?)
-            .ok_or(anyhow!("Query cost overflowed"))?;
+    let mut view_cost = 0u64;
+    for command in view.commands() {
+        view_cost = view_cost
+            .checked_add(cost_per_command(stack, &view_types, command, consensus_fee_version)?)
+            .ok_or(anyhow!("View cost overflowed"))?;
     }
-    Ok(query_cost)
+    Ok(view_cost)
 }
 
 /// Returns the total finalize cost for an execution by iterating over all concrete transitions.

synthesizer/process/src/finalize.rs

@@ -445,12 +445,12 @@ fn finalize_transition<N: Network, P: FinalizeStorage<N>>(
 
                     // Get the transition ID used to initialize the finalize registers.
                     // If the block height is greater than or equal to `ConsensusVersion::V3`, then use the top-level transition ID.
-                    // Otherwise, query the call graph for the child transition ID corresponding to the future that is being awaited.
+                    // Otherwise, view the call graph for the child transition ID corresponding to the future that is being awaited.
                     let consensus_version = N::CONSENSUS_VERSION(state.block_height())?;
                     let transition_id = if (ConsensusVersion::V1..=ConsensusVersion::V2).contains(&consensus_version) {
                         // Get the current transition ID. The finalize path always initializes
-                        // registers with `Some(transition_id)`; only the query path uses `None`,
-                        // and `await` is forbidden on the query path, so this is unreachable
+                        // registers with `Some(transition_id)`; only the view path uses `None`,
+                        // and `await` is forbidden on the view path, so this is unreachable
                         // there. Treat `None` as a logic error.
                         let transition_id = registers
                             .transition_id()
@@ -596,7 +596,7 @@ fn initialize_finalize_state<N: Network>(
 
 // A helper function to finalize all commands except `await`, updating the finalize operations and the counter.
 //
-// Generic over the store so the query evaluator (which passes either the canonical
+// Generic over the store so the view evaluator (which passes either the canonical
 // `FinalizeStore` or a read-only historic adapter) can reuse this dispatch.
 #[inline]
 pub(crate) fn finalize_command_except_await<N: Network>(

synthesizer/process/src/lib.rs

@@ -37,9 +37,9 @@ mod evaluate;
 mod execute;
 mod finalize;
 #[cfg(feature = "history")]
-mod query;
+mod view;
 #[cfg(feature = "history")]
-pub use query::evaluate_query_at_height;
+pub use view::evaluate_view_at_height;
 mod verify_deployment;
 mod verify_execution;
 mod verify_fee;

synthesizer/process/src/stack/finalize_registers/mod.rs

@@ -30,7 +30,7 @@ pub struct FinalizeRegisters<N: Network> {
     /// The global state for the finalize scope.
     state: FinalizeGlobalState,
     /// The transition ID for the finalize scope.
-    /// `None` on the query path (queries have no associated transition); always `Some(...)`
+    /// `None` on the view path (views have no associated transition); always `Some(...)`
     /// on the finalize / constructor paths.
     transition_id: Option<N::TransitionID>,
     /// The function name for the finalize scope.
@@ -41,7 +41,7 @@ pub struct FinalizeRegisters<N: Network> {
     /// The mapping of assigned registers to their values.
     registers: IndexMap<u64, Value<N>>,
     /// A nonce for finalize registers.
-    /// `None` on the query path; always `Some(...)` on the finalize / constructor paths.
+    /// `None` on the view path; always `Some(...)` on the finalize / constructor paths.
     nonce: Option<u64>,
     /// The tracker for the last register locator.
     last_register: Option<u64>,
@@ -51,7 +51,7 @@ impl<N: Network> FinalizeRegisters<N> {
     /// Initializes a new set of registers, given the finalize types.
     ///
     /// `transition_id` and `nonce` are `Option`s so that callers can express "no transition is
-    /// associated with this scope" (the query path) without needing a sentinel default value.
+    /// associated with this scope" (the view path) without needing a sentinel default value.
     /// On the finalize / constructor paths, both are always `Some(...)` and the absence of a
     /// transition ID at any read site (e.g. `rand.chacha`) is treated as a runtime error.
     #[inline]

synthesizer/process/src/stack/finalize_types/initialize.rs

@@ -43,35 +43,35 @@ impl<N: Network> FinalizeTypes<N> {
         Ok(finalize_types)
     }
 
-    /// Initializes a new instance of `FinalizeTypes` for the given query function.
-    /// Checks that the given query is well-formed for the given stack.
+    /// Initializes a new instance of `FinalizeTypes` for the given view function.
+    /// Checks that the given view is well-formed for the given stack.
     ///
-    /// Queries share the finalize register/command shape, but cannot await futures and cannot
+    /// Views share the finalize register/command shape, but cannot await futures and cannot
     /// produce side effects. The forbidden-command list (writes, async, await, call, rand.chacha)
-    /// is enforced at `QueryCore` construction; this function only needs to type-check the body.
+    /// is enforced at `ViewCore` construction; this function only needs to type-check the body.
     #[inline]
-    pub(super) fn initialize_finalize_types_from_query(
+    pub(super) fn initialize_finalize_types_from_view(
         stack: &Stack<N>,
-        query: &snarkvm_synthesizer_program::QueryCore<N>,
+        view: &snarkvm_synthesizer_program::ViewCore<N>,
     ) -> Result<Self> {
         let mut finalize_types = Self { inputs: IndexMap::new(), destinations: IndexMap::new() };
 
-        // Type-check the inputs. Query inputs are guaranteed to be plaintext at construction time.
-        for input in query.inputs() {
+        // Type-check the inputs. View inputs are guaranteed to be plaintext at construction time.
+        for input in view.inputs() {
             finalize_types.check_input(stack, input.register(), input.finalize_type())?;
         }
 
         // Type-check the commands.
-        for command in query.commands() {
-            finalize_types.check_command(stack, query.positions(), command)?;
+        for command in view.commands() {
+            finalize_types.check_command(stack, view.positions(), command)?;
         }
 
         // Type-check the outputs: each output operand must resolve and match the declared type.
-        for output in query.outputs() {
+        for output in view.outputs() {
             let actual = finalize_types.get_type_from_operand(stack, output.operand())?;
             if &actual != output.finalize_type() {
                 bail!(
-                    "Query output type mismatch: declared '{}' but operand '{}' has type '{}'",
+                    "View output type mismatch: declared '{}' but operand '{}' has type '{}'",
                     output.finalize_type(),
                     output.operand(),
                     actual,

synthesizer/process/src/stack/finalize_types/mod.rs

@@ -87,11 +87,11 @@ impl<N: Network> FinalizeTypes<N> {
         Self::initialize_finalize_types_from_finalize(stack, finalize)
     }
 
-    /// Initializes a new instance of `FinalizeTypes` for the given query function.
-    /// Checks that the given query is well-formed for the given stack.
+    /// Initializes a new instance of `FinalizeTypes` for the given view function.
+    /// Checks that the given view is well-formed for the given stack.
     #[inline]
-    pub fn from_query(stack: &Stack<N>, query: &snarkvm_synthesizer_program::QueryCore<N>) -> Result<Self> {
-        Self::initialize_finalize_types_from_query(stack, query)
+    pub fn from_view(stack: &Stack<N>, view: &snarkvm_synthesizer_program::ViewCore<N>) -> Result<Self> {
+        Self::initialize_finalize_types_from_view(stack, view)
     }
 
     /// Returns `true` if the given register exists.

synthesizer/process/src/stack/mod.rs

@@ -379,11 +379,11 @@ impl<N: Network> Stack<N> {
             }
         }
 
-        // Type-check every query function. The result is not cached on the stack here;
-        // it is recomputed by the query evaluator. This is acceptable for the prototype
-        // and ensures that ill-typed queries are rejected at deploy time.
-        for query in self.program.queries().values() {
-            let _ = FinalizeTypes::from_query(self, query)?;
+        // Type-check every view function. The result is not cached on the stack here;
+        // it is recomputed by the view evaluator. This is acceptable for the prototype
+        // and ensures that ill-typed views are rejected at deploy time.
+        for view in self.program.views().values() {
+            let _ = FinalizeTypes::from_view(self, view)?;
         }
 
         // Drop the locks since the types have been initialized.