cleanup some imports

Author: tcoratger

crates/lean_compiler/src/codegen/compiler.rs

@@ -1,3 +1,4 @@
+use crate::codegen::function::compile_function;
 use crate::{ir::*, lang::*};
 use lean_vm::*;
 use std::collections::BTreeMap;
@@ -39,7 +40,7 @@ impl Compiler {
         let mut memory_sizes = BTreeMap::new();
 
         for function in simple_program.functions.values() {
-            let instructions = crate::codegen::function::compile_function(function, self)?;
+            let instructions = compile_function(function, self)?;
             self.bytecode
                 .insert(Label::function(&function.name), instructions);
             memory_sizes.insert(function.name.clone(), self.stack_size);
@@ -108,7 +109,7 @@ mod tests {
             n_returned_vars: 1,
         };
 
-        let result = crate::codegen::function::compile_function(&function, &mut compiler);
+        let result = compile_function(&function, &mut compiler);
         assert!(result.is_ok());
 
         assert_eq!(compiler.func_name, "test");

crates/lean_compiler/src/codegen/function.rs

@@ -1,3 +1,4 @@
+use crate::codegen::{instruction::compile_lines, memory::find_internal_vars};
 use crate::{codegen::*, ir::*, lang::*};
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -9,7 +10,7 @@ pub fn compile_function(
     function: &SimpleFunction,
     compiler: &mut Compiler,
 ) -> Result<Vec<IntermediateInstruction>, String> {
-    let mut internal_vars = crate::codegen::memory::find_internal_vars(&function.instructions);
+    let mut internal_vars = find_internal_vars(&function.instructions);
     internal_vars.retain(|var| !function.arguments.contains(var));
 
     // memory layout: pc, fp, args, return_vars, internal_vars
@@ -34,12 +35,7 @@ pub fn compile_function(
     compiler.args_count = function.arguments.len();
 
     let mut declared_vars: BTreeSet<Var> = function.arguments.iter().cloned().collect();
-    crate::codegen::instruction::compile_lines(
-        &function.instructions,
-        compiler,
-        None,
-        &mut declared_vars,
-    )
+    compile_lines(&function.instructions, compiler, None, &mut declared_vars)
 }
 
 #[cfg(test)]

crates/lean_compiler/src/ir/conversion.rs

@@ -1,14 +1,12 @@
 use super::{
+    HighLevelOperation,
     types::{
         ArrayAccessType, ArrayManager, ConstMalloc, Counters, SimpleFunction, SimpleLine,
         VarOrConstMallocAccess,
     },
     utilities::find_variable_usage,
 };
-use crate::{
-    ir::HighLevelOperation,
-    lang::{Boolean, ConstExpression, Expression, Line, SimpleExpr, Var},
-};
+use crate::lang::{Boolean, ConstExpression, Expression, Line, SimpleExpr, Var};
 use std::collections::BTreeMap;
 use utils::ToUsize;
 
@@ -764,8 +762,7 @@ fn create_recursive_function(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::ir::types::*;
-    use crate::{ir::HighLevelOperation, lang::*};
+    use crate::lang::*;
 
     fn create_test_counters() -> Counters {
         Counters::default()

crates/lean_compiler/src/ir/value.rs

@@ -1,3 +1,4 @@
+use crate::backend::evaluation::{CodeGenerator, eval_const_expression_usize, try_as_constant};
 use crate::lang::{ConstExpression, SimpleExpr};
 use lean_vm::Label;
 use std::fmt::{Display, Formatter};
@@ -59,13 +60,10 @@ impl IntermediateValue {
     }
 
     /// Converts this value to a MemOrFp for low-level code generation.
-    pub fn try_into_mem_or_fp(
-        &self,
-        compiler: &crate::backend::evaluation::CodeGenerator,
-    ) -> Result<lean_vm::MemOrFp, String> {
+    pub fn try_into_mem_or_fp(&self, compiler: &CodeGenerator) -> Result<lean_vm::MemOrFp, String> {
         match self {
             Self::MemoryAfterFp { offset } => Ok(lean_vm::MemOrFp::MemoryAfterFp {
-                offset: crate::backend::evaluation::eval_const_expression_usize(offset, compiler),
+                offset: eval_const_expression_usize(offset, compiler),
             }),
             Self::Fp => Ok(lean_vm::MemOrFp::Fp),
             _ => Err(format!("Cannot convert {self:?} to MemOrFp")),
@@ -75,14 +73,14 @@ impl IntermediateValue {
     /// Converts this value to a MemOrConstant for low-level code generation.
     pub fn try_into_mem_or_constant(
         &self,
-        compiler: &crate::backend::evaluation::CodeGenerator,
+        compiler: &CodeGenerator,
     ) -> Result<lean_vm::MemOrConstant, String> {
-        if let Some(cst) = crate::backend::evaluation::try_as_constant(self, compiler) {
+        if let Some(cst) = try_as_constant(self, compiler) {
             return Ok(lean_vm::MemOrConstant::Constant(cst));
         }
         if let Self::MemoryAfterFp { offset } = self {
             return Ok(lean_vm::MemOrConstant::MemoryAfterFp {
-                offset: crate::backend::evaluation::eval_const_expression_usize(offset, compiler),
+                offset: eval_const_expression_usize(offset, compiler),
             });
         }
         Err(format!("Cannot convert {self:?} to MemOrConstant"))

crates/lean_compiler/src/lang/values/constant.rs

@@ -4,6 +4,7 @@ use p3_util::log2_ceil_usize;
 use std::fmt::{Display, Formatter};
 use utils::ToUsize;
 
+use crate::lang::ast::{Expression, SimpleExpr};
 use crate::{F, ir::HighLevelOperation};
 
 /// Constant value types for compile-time computation.
@@ -108,11 +109,10 @@ impl ConstExpression {
     }
 }
 
-impl TryFrom<crate::lang::ast::Expression> for ConstExpression {
+impl TryFrom<Expression> for ConstExpression {
     type Error = ();
 
-    fn try_from(value: crate::lang::ast::Expression) -> Result<Self, Self::Error> {
-        use crate::lang::ast::{Expression, SimpleExpr};
+    fn try_from(value: Expression) -> Result<Self, Self::Error> {
         match value {
             Expression::Value(SimpleExpr::Constant(const_expr)) => Ok(const_expr),
             Expression::Value(_) => Err(()),
@@ -318,8 +318,6 @@ mod tests {
 
     #[test]
     fn test_const_expression_try_from() {
-        use crate::lang::ast::{Expression, SimpleExpr};
-
         // Test successful conversion
         let const_expr = ConstExpression::scalar(10);
         let expr = Expression::Value(SimpleExpr::Constant(const_expr.clone()));

crates/lean_compiler/src/passes/ast_to_ir.rs

@@ -7,10 +7,7 @@
 //! ready for code generation.
 
 use super::{Pass, PassResult};
-use crate::ir::{
-    SimpleProgram, conversion,
-    types::{ArrayManager, ConstMalloc, Counters},
-};
+use crate::ir::{ArrayManager, ConstMalloc, Counters, SimpleFunction, SimpleProgram, conversion};
 use crate::lang::Program;
 use std::collections::BTreeMap;
 
@@ -71,7 +68,7 @@ impl AstToIrPass {
                 .collect();
 
             // Create the IR function
-            let ir_function = crate::ir::types::SimpleFunction {
+            let ir_function = SimpleFunction {
                 name: name.clone(),
                 arguments: ir_arguments,
                 n_returned_vars: ast_function.n_returned_vars,