feat: update AST architecture and test module flow

- Refactor AST to include tests and modules
- Add simple tests for module flow

Author: LesterEvSe

Cargo.lock

@@ -0,0 +1,12 @@
+use merkle::build_root::get_root;
+use math::simple_op::hash;
+
+pub fn get_block_value_hash(prev_hash: u32, tx1: u32, tx2: u32) -> u32 {
+    let root: u32 = get_root(tx1, tx2);
+    hash(prev_hash, root);
+}
+
+fn main() {
+    let block_val_hash: u32 = get_block_value(5, 10, 20);
+    assert!(jet::eq_32(block_val_hash, 27));
+}

examples/multiple_libs/main.simf

@@ -0,0 +1,3 @@
+pub fn hash(x: u32, y: u32) -> u32 {
+    jet::xor_32(x, y)
+}

examples/multiple_libs/math/simple_op.simf

@@ -0,0 +1,5 @@
+use math::simple_op::hash;
+
+pub fn get_root(tx1: u32, tx2: u32) -> u32 {
+    hash(tx1, tx2)
+}

examples/multiple_libs/merkle/build_root.simf

@@ -0,0 +1,11 @@
+pub use temp::two::two;
+use temp::funcs::{get_five, Smth};
+
+fn seven() -> u32 {
+    7
+}
+
+fn main() {
+    let (_, temp): (bool, u32) = jet::add_32(two(), get_five());
+    assert!(jet::eq_32(temp, seven()));
+}

examples/single_lib/main.simf

@@ -0,0 +1,5 @@
+pub type Smth = u32;
+
+pub fn get_five() -> u32 {
+    5
+}

examples/single_lib/temp/funcs.simf

@@ -0,0 +1,5 @@
+pub use temp::funcs::Smth;
+
+pub fn two() -> Smth {
+    2
+}

examples/single_lib/temp/two.simf

@@ -9,6 +9,7 @@ use miniscript::iter::{Tree, TreeLike};
 use simplicity::jet::Elements;
 
 use crate::debug::{CallTracker, DebugSymbols, TrackedCallName};
+use crate::driver::ProgramResolutions;
 use crate::error::{Error, RichError, Span, WithSpan};
 use crate::num::{NonZeroPow2Usize, Pow2Usize};
 use crate::parse::MatchPattern;
@@ -19,7 +20,7 @@ use crate::types::{
 };
 use crate::value::{UIntValue, Value};
 use crate::witness::{Parameters, WitnessTypes, WitnessValues};
-use crate::{impl_eq_hash, parse};
+use crate::{driver, impl_eq_hash, parse, SourceName};
 
 /// A program consists of the main function.
 ///
@@ -520,8 +521,12 @@ impl TreeLike for ExprTree<'_> {
 /// 2. Resolving type aliases
 /// 3. Assigning types to each witness expression
 /// 4. Resolving calls to custom functions
-#[derive(Clone, Debug, Eq, PartialEq, Default)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 struct Scope {
+    resolutions: ProgramResolutions,
+    paths: Arc<[SourceName]>,
+    file_id: usize, // ID of the file from which the function is called.
+
     variables: Vec<HashMap<Identifier, ResolvedType>>,
     aliases: HashMap<AliasName, ResolvedType>,
     parameters: HashMap<WitnessName, ResolvedType>,
@@ -531,7 +536,44 @@ struct Scope {
     call_tracker: CallTracker,
 }
 
+impl Default for Scope {
+    fn default() -> Self {
+        Self {
+            resolutions: Arc::from([]),
+            paths: Arc::from([]),
+            file_id: 0,
+            variables: Vec::new(),
+            aliases: HashMap::new(),
+            parameters: HashMap::new(),
+            witnesses: HashMap::new(),
+            functions: HashMap::new(),
+            is_main: false,
+            call_tracker: CallTracker::default(),
+        }
+    }
+}
+
 impl Scope {
+    pub fn new(resolutions: ProgramResolutions, paths: Arc<[SourceName]>) -> Self {
+        Self {
+            resolutions,
+            paths,
+            file_id: 0,
+            variables: Vec::new(),
+            aliases: HashMap::new(),
+            parameters: HashMap::new(),
+            witnesses: HashMap::new(),
+            functions: HashMap::new(),
+            is_main: false,
+            call_tracker: CallTracker::default(),
+        }
+    }
+
+    /// Access to current function file id.
+    pub fn file_id(&self) -> usize {
+        self.file_id
+    }
+
     /// Check if the current scope is topmost.
     pub fn is_topmost(&self) -> bool {
         self.variables.is_empty()
@@ -542,6 +584,11 @@ impl Scope {
         self.variables.push(HashMap::new());
     }
 
+    pub fn push_function_scope(&mut self, file_id: usize) {
+        self.push_scope();
+        self.file_id = file_id;
+    }
+
     /// Push the scope of the main function onto the stack.
     ///
     /// ## Panics
@@ -564,6 +611,11 @@ impl Scope {
         self.variables.pop().expect("Stack is empty");
     }
 
+    pub fn pop_function_scope(&mut self, previous_file_id: usize) {
+        self.pop_scope();
+        self.file_id = previous_file_id;
+    }
+
     /// Pop the scope of the main function from the stack.
     ///
     /// ## Panics
@@ -693,9 +745,39 @@ impl Scope {
         }
     }
 
-    /// Get the definition of a custom function.
-    pub fn get_function(&self, name: &FunctionName) -> Option<&CustomFunction> {
-        self.functions.get(name)
+    /// Get the definition of a custom function with visibility and existence checks.
+    ///
+    /// # Errors
+    ///
+    /// - `Error::FileNotFound`: The specified `file_id` does not exist in the resolutions.
+    /// - `Error::FunctionUndefined`: The function is not found in the file's scope OR not defined globally.
+    /// - `Error::FunctionIsPrivate`: The function exists but is private (and thus not accessible).
+    pub fn get_function(&self, name: &FunctionName) -> Result<&CustomFunction, Error> {
+        // The order of the errors is important!
+        let function = self
+            .functions
+            .get(name)
+            .ok_or_else(|| Error::FunctionUndefined(name.clone()))?;
+
+        let source_name = self.paths[self.file_id].clone();
+
+        let file_scope = match source_name {
+            SourceName::Real(path) => self
+                .resolutions
+                .get(self.file_id)
+                .ok_or(Error::FileNotFound(path))?,
+            SourceName::Virtual(_) => {
+                return Ok(function);
+            }
+        };
+
+        let identifier: Identifier = name.clone().into();
+
+        if file_scope.contains_key(&identifier) {
+            Ok(function)
+        } else {
+            Err(Error::FunctionIsPrivate(name.clone()))
+        }
     }
 
     /// Track a call expression with its span.
@@ -718,9 +800,10 @@ trait AbstractSyntaxTree: Sized {
 }
 
 impl Program {
-    pub fn analyze(from: &parse::Program) -> Result<Self, RichError> {
+    // TODO: Add visibility check inside program
+    pub fn analyze(from: &driver::Program) -> Result<Self, RichError> {
         let unit = ResolvedType::unit();
-        let mut scope = Scope::default();
+        let mut scope = Scope::new(Arc::from(from.resolutions()), Arc::from(from.paths()));
         let items = from
             .items()
             .iter()
@@ -746,36 +829,37 @@ impl Program {
 }
 
 impl AbstractSyntaxTree for Item {
-    type From = parse::Item;
+    type From = driver::Item;
 
     fn analyze(from: &Self::From, ty: &ResolvedType, scope: &mut Scope) -> Result<Self, RichError> {
         assert!(ty.is_unit(), "Items cannot return anything");
         assert!(scope.is_topmost(), "Items live in the topmost scope only");
 
         match from {
-            parse::Item::TypeAlias(alias) => {
+            driver::Item::TypeAlias(alias) => {
                 scope
                     .insert_alias(alias.name().clone(), alias.ty().clone())
                     .with_span(alias)?;
                 Ok(Self::TypeAlias)
             }
-            parse::Item::Function(function) => {
+            driver::Item::Function(function) => {
                 Function::analyze(function, ty, scope).map(Self::Function)
             }
-            parse::Item::Use(_) => todo!(),
-            parse::Item::Module => Ok(Self::Module),
+            driver::Item::Module => Ok(Self::Module),
         }
     }
 }
 
 impl AbstractSyntaxTree for Function {
-    type From = parse::Function;
+    type From = driver::Function;
 
     fn analyze(from: &Self::From, ty: &ResolvedType, scope: &mut Scope) -> Result<Self, RichError> {
         assert!(ty.is_unit(), "Function definitions cannot return anything");
         assert!(scope.is_topmost(), "Items live in the topmost scope only");
+        let previous_file_id = scope.file_id();
 
         if from.name().as_inner() != "main" {
+            let file_id = from.file_id();
             let params = from
                 .params()
                 .iter()
@@ -792,12 +876,12 @@ impl AbstractSyntaxTree for Function {
                 .map(|aliased| scope.resolve(aliased).with_span(from))
                 .transpose()?
                 .unwrap_or_else(ResolvedType::unit);
-            scope.push_scope();
+            scope.push_function_scope(file_id);
             for param in params.iter() {
                 scope.insert_variable(param.identifier().clone(), param.ty().clone());
             }
             let body = Expression::analyze(from.body(), &ret, scope).map(Arc::new)?;
-            scope.pop_scope();
+            scope.pop_function_scope(previous_file_id);
             debug_assert!(scope.is_topmost());
             let function = CustomFunction { params, body };
             scope
@@ -1322,14 +1406,9 @@ impl AbstractSyntaxTree for CallName {
                 .get_function(name)
                 .cloned()
                 .map(Self::Custom)
-                .ok_or(Error::FunctionUndefined(name.clone()))
                 .with_span(from),
             parse::CallName::ArrayFold(name, size) => {
-                let function = scope
-                    .get_function(name)
-                    .cloned()
-                    .ok_or(Error::FunctionUndefined(name.clone()))
-                    .with_span(from)?;
+                let function = scope.get_function(name).cloned().with_span(from)?;
                 // A function that is used in a array fold has the signature:
                 //   fn f(element: E, accumulator: A) -> A
                 if function.params().len() != 2 || function.params()[1].ty() != function.body().ty()
@@ -1340,11 +1419,7 @@ impl AbstractSyntaxTree for CallName {
                 }
             }
             parse::CallName::Fold(name, bound) => {
-                let function = scope
-                    .get_function(name)
-                    .cloned()
-                    .ok_or(Error::FunctionUndefined(name.clone()))
-                    .with_span(from)?;
+                let function = scope.get_function(name).cloned().with_span(from)?;
                 // A function that is used in a list fold has the signature:
                 //   fn f(element: E, accumulator: A) -> A
                 if function.params().len() != 2 || function.params()[1].ty() != function.body().ty()
@@ -1355,11 +1430,7 @@ impl AbstractSyntaxTree for CallName {
                 }
             }
             parse::CallName::ForWhile(name) => {
-                let function = scope
-                    .get_function(name)
-                    .cloned()
-                    .ok_or(Error::FunctionUndefined(name.clone()))
-                    .with_span(from)?;
+                let function = scope.get_function(name).cloned().with_span(from)?;
                 // A function that is used in a for-while loop has the signature:
                 //   fn f(accumulator: A, readonly_context: C, counter: u{N}) -> Either<B, A>
                 // where
@@ -1435,6 +1506,9 @@ fn analyze_named_module(
     from: &parse::ModuleProgram,
 ) -> Result<HashMap<WitnessName, Value>, RichError> {
     let unit = ResolvedType::unit();
+
+    // IMPORTANT! If modules allow imports, then we need to consider
+    // passing the resolution conetxt by calling `Scope::new(resolutions)`
     let mut scope = Scope::default();
     let items = from
         .items()