compiler: small function name changes

Author: tcoratger

crates/leanVm/src/intermediate_bytecode/intermediate_value.rs

@@ -28,7 +28,7 @@ impl IntermediateValue {
     pub fn try_into_mem_or_fp(&self, compiler: &Compiler) -> Result<MemOrFp, String> {
         match self {
             Self::MemoryAfterFp { offset } => Ok(MemOrFp::MemoryAfterFp {
-                offset: offset.eval_const_expression_usize(compiler),
+                offset: offset.eval_usize(compiler),
             }),
             Self::Fp => Ok(MemOrFp::Fp),
             Self::Constant(_) => Err(format!("Cannot convert {self:?} to MemOrFp")),
@@ -41,7 +41,7 @@ impl IntermediateValue {
         }
         if let Self::MemoryAfterFp { offset } = self {
             return Ok(MemOrConstant::MemoryAfterFp {
-                offset: offset.eval_const_expression_usize(compiler),
+                offset: offset.eval_usize(compiler),
             });
         }
         Err(format!("Cannot convert {self:?} to MemOrConstant"))
@@ -50,7 +50,7 @@ impl IntermediateValue {
     #[must_use]
     pub fn try_as_constant(&self, compiler: &Compiler) -> Option<F> {
         if let Self::Constant(c) = self {
-            Some(c.eval_const_expression(compiler))
+            Some(c.eval(compiler))
         } else {
             None
         }

crates/leanVm/src/intermediate_bytecode/mod.rs

@@ -74,15 +74,15 @@ impl IntermediateBytecode {
             }
             if let IntermediateValue::MemoryAfterFp { offset } = value {
                 return Some(MemOrConstant::MemoryAfterFp {
-                    offset: offset.eval_const_expression_usize(&compiler),
+                    offset: offset.eval_usize(&compiler),
                 });
             }
             None
         };
 
         let try_as_mem_or_fp = |value: &IntermediateValue| match value {
             IntermediateValue::MemoryAfterFp { offset } => Some(MemOrFp::MemoryAfterFp {
-                offset: offset.eval_const_expression_usize(&compiler),
+                offset: offset.eval_usize(&compiler),
             }),
             IntermediateValue::Fp => Some(MemOrFp::Fp),
             IntermediateValue::Constant(_) => None,
@@ -145,17 +145,17 @@ impl IntermediateBytecode {
                         res,
                     } => {
                         low_level_bytecode.push(Instruction::Deref(DerefInstruction {
-                            shift_0: shift_0.eval_const_expression_usize(&compiler),
-                            shift_1: shift_1.eval_const_expression_usize(&compiler),
+                            shift_0: shift_0.eval_usize(&compiler),
+                            shift_1: shift_1.eval_usize(&compiler),
                             res: match res {
                                 IntermediaryMemOrFpOrConstant::MemoryAfterFp { offset } => {
                                     MemOrFpOrConstant::MemoryAfterFp {
-                                        offset: offset.eval_const_expression_usize(&compiler),
+                                        offset: offset.eval_usize(&compiler),
                                     }
                                 }
                                 IntermediaryMemOrFpOrConstant::Fp => MemOrFpOrConstant::Fp,
                                 IntermediaryMemOrFpOrConstant::Constant(c) => {
-                                    MemOrFpOrConstant::Constant(c.eval_const_expression(&compiler))
+                                    MemOrFpOrConstant::Constant(c.eval(&compiler))
                                 }
                             },
                         }));
@@ -213,7 +213,7 @@ impl IntermediateBytecode {
                             arg0: arg0.try_into_mem_or_constant(&compiler).unwrap(),
                             arg1: arg1.try_into_mem_or_constant(&compiler).unwrap(),
                             res: res.try_into_mem_or_fp(&compiler).unwrap(),
-                            size: size.eval_const_expression_usize(&compiler),
+                            size: size.eval_usize(&compiler),
                         }));
                     }
                     IntermediateInstruction::MultilinearEval {
@@ -227,7 +227,7 @@ impl IntermediateBytecode {
                                 coeffs: coeffs.try_into_mem_or_constant(&compiler).unwrap(),
                                 point: point.try_into_mem_or_constant(&compiler).unwrap(),
                                 res: res.try_into_mem_or_fp(&compiler).unwrap(),
-                                n_vars: n_vars.eval_const_expression_usize(&compiler),
+                                n_vars: n_vars.eval_usize(&compiler),
                             },
                         ));
                     }
@@ -255,7 +255,7 @@ impl IntermediateBytecode {
                     } => {
                         let size = try_as_mem_or_constant(&size).unwrap();
                         let hint = Hint::RequestMemory {
-                            offset: offset.eval_const_expression_usize(&compiler),
+                            offset: offset.eval_usize(&compiler),
                             vectorized,
                             size,
                         };

crates/leanVm/src/lang/const_expr.rs

@@ -75,13 +75,15 @@ impl ConstExpression {
         )
     }
 
-    #[must_use] pub fn eval_const_expression(&self, compiler: &Compiler) -> F {
-        self.eval_with(&|cst| Some(F::from_usize(cst.eval_constant_value(compiler))))
+    #[must_use]
+    pub fn eval(&self, compiler: &Compiler) -> F {
+        self.eval_with(&|cst| Some(F::from_usize(cst.eval(compiler))))
             .unwrap()
     }
 
-    #[must_use] pub fn eval_const_expression_usize(&self, compiler: &Compiler) -> usize {
-        self.eval_const_expression(compiler)
+    #[must_use]
+    pub fn eval_usize(&self, compiler: &Compiler) -> usize {
+        self.eval(compiler)
             .as_canonical_biguint()
             .try_into()
             .unwrap()

crates/leanVm/src/lang/constant_value.rs

@@ -16,7 +16,8 @@ pub enum ConstantValue {
 }
 
 impl ConstantValue {
-    #[must_use] pub fn eval_constant_value(&self, compiler: &Compiler) -> usize {
+    #[must_use]
+    pub fn eval(&self, compiler: &Compiler) -> usize {
         match self {
             Self::Scalar(scalar) => *scalar,
             Self::PublicInputStart => PUBLIC_INPUT_START.offset,