Finished implementing ability to call normal functions at compile-time

Author: IsaacShelton

src/components/job/src/cfg/mod.rs

@@ -116,6 +116,12 @@ impl<'env> Cfg<'env> {
         })
     }
 
+    pub fn iter_instrs_unordered(&self) -> impl Iterator<Item = &Instr<'env>> {
+        self.basicblocks
+            .iter()
+            .flat_map(|(_bb_id, bb)| bb.instrs.iter())
+    }
+
     pub fn get_typed(
         &self,
         cfg_value: CfgValue,

src/components/job/src/conform/to_default.rs

@@ -11,7 +11,7 @@ use primitives::{CIntegerAssumptions, IntegerSign};
 use source_files::Source;
 use target::Target;
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Conform<'env> {
     pub ty: UnaliasedType<'env>,
     pub cast: Option<UnaryCast<'env>>,
@@ -42,15 +42,16 @@ impl<'env> Conform<'env> {
                 panic!("cannot implicitly dereference non deref'$T type");
             };
 
+            from_ty = UnaliasedType(after_deref);
+
             result = Self::new(
                 from_ty,
                 UnaryCast::Dereference {
-                    after_deref: UnaliasedType(*after_deref),
+                    after_deref: from_ty,
                     then: std::mem::take(&mut result.cast).map(|cast| &*ctx.alloc(cast)),
                 },
             );
 
-            from_ty = UnaliasedType(after_deref);
             count -= 1;
         }
 

src/components/job/src/execution/lower/function_body/mod.rs

@@ -1,6 +1,6 @@
 use crate::{
     Continuation, Executable, ExecutionCtx, Executor, SuspendMany, execution::lower::LowerType, ir,
-    module_graph::ModuleView, repr::FuncHead,
+    repr::FuncHead,
 };
 use by_address::ByAddress;
 use derivative::Derivative;
@@ -9,7 +9,6 @@ use std::sync::OnceLock;
 #[derive(Clone, Derivative)]
 #[derivative(Debug, PartialEq, Eq, Hash)]
 pub struct LowerFunctionHead<'env> {
-    view: &'env ModuleView<'env>,
     head: ByAddress<&'env FuncHead<'env>>,
 
     #[derivative(Hash = "ignore")]
@@ -19,9 +18,8 @@ pub struct LowerFunctionHead<'env> {
 }
 
 impl<'env> LowerFunctionHead<'env> {
-    pub fn new(view: &'env ModuleView<'env>, head: &'env FuncHead<'env>) -> Self {
+    pub fn new(head: &'env FuncHead<'env>) -> Self {
         Self {
-            view,
             head: ByAddress(head),
             inner_types: None,
         }
@@ -36,7 +34,8 @@ impl<'env> Executable<'env> for LowerFunctionHead<'env> {
         executor: &Executor<'env>,
         ctx: &mut ExecutionCtx<'env>,
     ) -> Result<Self::Output, Continuation<'env>> {
-        let ir = self.view.web.graph(self.view.graph, |graph| graph.ir);
+        let view = self.head.view;
+        let ir = view.web.graph(view.graph, |graph| graph.ir);
 
         let Some(inner_types) = executor.demand_many(&self.inner_types) else {
             let suspend_on_types = self
@@ -50,7 +49,7 @@ impl<'env> Executable<'env> for LowerFunctionHead<'env> {
             return suspend_many!(
                 self.inner_types,
                 suspend_on_types
-                    .map(|ty| executor.request(LowerType::new(self.view, ty.0)))
+                    .map(|ty| executor.request(LowerType::new(view, ty.0)))
                     .collect(),
                 ctx
             );

src/components/job/src/execution/lower/function_head.rs

@@ -79,7 +79,7 @@ impl<'env> Executable<'env> for ProcessFunction<'env> {
                 let Some(resolved_head) = executor.demand(self.resolving_head) else {
                     return suspend!(
                         self.resolving_head,
-                        executor.request(ResolveFunctionHead::new(self.view, &self.func.head)),
+                        executor.request(ResolveFunctionHead::new(self.view, &self.func)),
                         ctx
                     );
                 };
@@ -105,11 +105,7 @@ impl<'env> Executable<'env> for ProcessFunction<'env> {
                 let Some(resolved_body) = executor.demand(self.resolving_body) else {
                     return suspend!(
                         self.resolving_body,
-                        executor.request(ResolveFunctionBody::new(
-                            self.view,
-                            &self.func,
-                            resolved_head
-                        )),
+                        executor.request(ResolveFunctionBody::new(self.view, resolved_head)),
                         ctx
                     );
                 };
@@ -126,7 +122,7 @@ impl<'env> Executable<'env> for ProcessFunction<'env> {
         let Some(lowered_head) = executor.demand(self.lowering_head) else {
             return suspend!(
                 self.lowering_head,
-                executor.request(LowerFunctionHead::new(self.view, resolved_head)),
+                executor.request(LowerFunctionHead::new(resolved_head)),
                 ctx
             );
         };
@@ -135,7 +131,6 @@ impl<'env> Executable<'env> for ProcessFunction<'env> {
             return suspend!(
                 self.lowering_body,
                 executor.request(LowerFunctionBody::new(
-                    self.view,
                     lowered_head,
                     resolved_head,
                     resolved_body

src/components/job/src/execution/process/function.rs

@@ -1,5 +1,5 @@
 use crate::{
-    Continuation, Executable, ExecutionCtx, Executor, Suspend,
+    Continuation, Executable, ExecutionCtx, Executor, InstrKind, Pending, Suspend,
     execution::{
         lower::{LowerFunctionBody, LowerFunctionHead},
         resolve::{ResolveFunctionBody, ResolveFunctionHead},
@@ -13,6 +13,8 @@ use attributes::{Exposure, Privacy, SymbolOwnership, Tag};
 use by_address::ByAddress;
 use derivative::Derivative;
 use diagnostics::ErrorDiagnostic;
+use itertools::Itertools;
+use std::collections::HashMap;
 
 #[derive(Clone, Derivative)]
 #[derivative(Debug, PartialEq, Eq, Hash)]
@@ -44,6 +46,30 @@ pub struct ResolveEvaluation<'env> {
     #[derivative(Debug = "ignore")]
     #[derivative(PartialEq = "ignore")]
     lowered_func_body: Suspend<'env, ()>,
+
+    #[derivative(Hash = "ignore")]
+    #[derivative(Debug = "ignore")]
+    #[derivative(PartialEq = "ignore")]
+    transitive_func_state: TransitiveFuncState<'env>,
+}
+
+/// State machine for completing transitive function dependencies
+#[derive(Clone)]
+enum TransitiveFuncState<'env> {
+    Initialize,
+    Step {
+        scan_next: Vec<&'env FuncBody<'env>>,
+        resolved_bodies: HashMap<ByAddress<&'env FuncHead<'env>>, &'env FuncBody<'env>>,
+        requests: HashMap<ByAddress<&'env FuncHead<'env>>, Pending<'env, &'env FuncBody<'env>>>,
+    },
+    LowerBodies(
+        Vec<(
+            &'env FuncHead<'env>,
+            &'env FuncBody<'env>,
+            Pending<'env, ir::FuncRef<'env>>,
+        )>,
+    ),
+    Finished,
 }
 
 impl<'env> ResolveEvaluation<'env> {
@@ -56,6 +82,7 @@ impl<'env> ResolveEvaluation<'env> {
             resolved_func_body: None,
             lowered_func_head: None,
             lowered_func_body: None,
+            transitive_func_state: TransitiveFuncState::Initialize,
         }
     }
 }
@@ -96,7 +123,7 @@ impl<'env> Executable<'env> for ResolveEvaluation<'env> {
         let Some(resolved_func_head) = executor.demand(self.resolved_func_head) else {
             return suspend!(
                 self.resolved_func_head,
-                executor.request(ResolveFunctionHead::new(self.comptime_view, &ast_func.head)),
+                executor.request(ResolveFunctionHead::new(self.comptime_view, &ast_func)),
                 ctx
             );
         };
@@ -106,30 +133,114 @@ impl<'env> Executable<'env> for ResolveEvaluation<'env> {
                 self.resolved_func_body,
                 executor.request(ResolveFunctionBody::new(
                     self.comptime_view,
-                    ast_func,
                     resolved_func_head
                 )),
                 ctx
             );
         };
 
-        // 3) Lower the function
+        // 3) Resolve transitive function dependencies
+        if let TransitiveFuncState::Initialize = &self.transitive_func_state {
+            self.transitive_func_state = TransitiveFuncState::Step {
+                scan_next: vec![resolved_func_body],
+                resolved_bodies: HashMap::new(),
+                requests: HashMap::new(),
+            };
+        }
+
+        match &mut self.transitive_func_state {
+            TransitiveFuncState::Initialize => unreachable!(),
+            TransitiveFuncState::Step {
+                scan_next,
+                resolved_bodies,
+                requests,
+            } => {
+                // Receive completed resolved function bodies
+                {
+                    let truth = executor.truth.read().unwrap();
+                    for (head, pending) in std::mem::take(requests) {
+                        let body = truth.demand(pending);
+                        resolved_bodies.insert(head, body);
+                        scan_next.push(body);
+                    }
+                }
+
+                // Search newly resolved function bodies
+                for body in scan_next.drain(..) {
+                    for instr in body.cfg.iter_instrs_unordered() {
+                        // For any function calls made
+                        if let InstrKind::Call(_, call_target) = &instr.kind {
+                            let call_target = call_target.as_ref().unwrap();
+                            let key = ByAddress(call_target.callee);
+
+                            // If we didn't already resolve the callee and aren't already planning
+                            // to request the callee to be resolved
+                            if !resolved_bodies.contains_key(&key) && !requests.contains_key(&key) {
+                                // Then add the callee to the set of functions to resolve in the next
+                                // suspend.
+                                requests.insert(
+                                    key,
+                                    executor.request(ResolveFunctionBody::new(key.view, key.0)),
+                                );
+                            }
+                        }
+                    }
+                }
+
+                // Suspend and continue stepping if any requests need to be made
+                if !requests.is_empty() {
+                    ctx.suspend_on(requests.iter().map(|(_, pending)| pending));
+                    return Err(Continuation::suspend(self));
+                }
+
+                // Otherwise, all function CFG bodies have been resolved,
+                // and now we have to lower all of the function heads used...
+                let mut pending_heads = Vec::new();
+                for (head, body) in resolved_bodies {
+                    let request = executor.request(LowerFunctionHead::new(head));
+                    pending_heads.push((**head, *body, request));
+                }
+
+                // Suspend on all function heads being lowered that we need
+                ctx.suspend_on(pending_heads.iter().map(|(_, _, pending)| pending));
+                self.transitive_func_state = TransitiveFuncState::LowerBodies(pending_heads);
+                return Err(Continuation::suspend(self));
+            }
+            TransitiveFuncState::LowerBodies(pending_heads) => {
+                // Extract lowered function heads that we waited on
+                let pending = {
+                    let truth = executor.truth.read().unwrap();
+                    pending_heads
+                        .into_iter()
+                        .map(|(head, body, request)| {
+                            let ir_func_ref = truth.demand(*request);
+                            LowerFunctionBody::new(*ir_func_ref, head, body)
+                        })
+                        .collect_vec()
+                };
+
+                // Suspend on all function bodies being lowered that we need
+                ctx.suspend_on(executor.request_many(pending.into_iter()));
+                self.transitive_func_state = TransitiveFuncState::Finished;
+                return Err(Continuation::suspend(self));
+            }
+            TransitiveFuncState::Finished => (),
+        }
+
+        // 4) Lower the entry point function head
         let Some(lowered_func_head) = executor.demand(self.lowered_func_head) else {
             return suspend!(
                 self.lowered_func_head,
-                executor.request(LowerFunctionHead::new(
-                    self.comptime_view,
-                    resolved_func_head
-                )),
+                executor.request(LowerFunctionHead::new(resolved_func_head)),
                 ctx
             );
         };
 
+        // 5) Lower the entry point function body
         let Some(_lowered_func_body) = executor.demand(self.lowered_func_body) else {
             return suspend!(
                 self.lowered_func_body,
                 executor.request(LowerFunctionBody::new(
-                    self.comptime_view,
                     lowered_func_head,
                     resolved_func_head,
                     resolved_func_body,
@@ -138,10 +249,10 @@ impl<'env> Executable<'env> for ResolveEvaluation<'env> {
             );
         };
 
-        // 4) Obtain the intermediate representation for comptime so far
+        // 6) Obtain the intermediate representation for comptime so far
         let ir = self.comptime_view.graph(|graph| graph.ir);
 
-        // 5) Interpret the function and raise any interpretation errors
+        // 7) Interpret the function and raise any interpretation errors
         let mut interpreter =
             Interpreter::new(ComptimeSystemSyscallHandler::default(), ir, Some(1_000_000));
 
@@ -152,10 +263,10 @@ impl<'env> Executable<'env> for ResolveEvaluation<'env> {
         // The actual entry point result should be void
         entry_point_result.kind.unwrap_literal().unwrap_void();
 
-        // 6) Examine the result value that was baked by the function
+        // 8) Examine the result value that was baked by the function
         let exit_value = interpreter.exit_value();
 
-        // 7) Expect that the exit value is transferrable
+        // 9) Expect that the exit value is transferrable
         let Some(exit_value) = exit_value else {
             return Err(ErrorDiagnostic::new(
                 "Compile-time evaluation must evaluate to transferable value",
@@ -164,7 +275,7 @@ impl<'env> Executable<'env> for ResolveEvaluation<'env> {
             .into());
         };
 
-        // 8) Translate the constant value into a literal value
+        // 10) Translate the constant value into a literal value
         // and/or static data that can be used as a literal.
         Ok(ctx.alloc(Evaluated::new_unsigned(exit_value)))
 

src/components/job/src/execution/resolve/evaluate.rs

@@ -36,7 +36,6 @@ use std::collections::HashSet;
 #[derivative(Debug, PartialEq, Eq, Hash)]
 pub struct ResolveFunctionBody<'env> {
     view: &'env ModuleView<'env>,
-    func: ByAddress<&'env ast::Func>,
     resolved_head: ByAddress<&'env FuncHead<'env>>,
 
     #[derivative(Hash = "ignore")]
@@ -86,14 +85,9 @@ pub struct ResolveFunctionBody<'env> {
 }
 
 impl<'env> ResolveFunctionBody<'env> {
-    pub fn new(
-        view: &'env ModuleView<'env>,
-        func: &'env ast::Func,
-        resolved_head: &'env FuncHead<'env>,
-    ) -> Self {
+    pub fn new(view: &'env ModuleView<'env>, resolved_head: &'env FuncHead<'env>) -> Self {
         Self {
             view,
-            func: ByAddress(func),
             resolved_head: ByAddress(resolved_head),
             inner_types: None,
             rev_post_order: None,
@@ -136,7 +130,7 @@ impl<'env> Executable<'env> for ResolveFunctionBody<'env> {
         executor: &Executor<'env>,
         ctx: &mut ExecutionCtx<'env>,
     ) -> Result<Self::Output, Continuation<'env>> {
-        let def = self.func;
+        let def = self.resolved_head.ast_func;
         let builtin_types = self.view.compiler().builtin_types;
 
         // 0) Foreign functions do not have bodies
@@ -1168,9 +1162,14 @@ impl<'env> Executable<'env> for ResolveFunctionBody<'env> {
                     )?;
 
                     if !conformed.ty.0.kind.is_boolean() {
-                        return Err(
-                            ErrorDiagnostic::new("Expected 'bool' value", instr.source).into()
-                        );
+                        return Err(ErrorDiagnostic::new(
+                            format!(
+                                "Expected `bool` value, got `{}`",
+                                conformed.ty.display_one(self.view)
+                            ),
+                            instr.source,
+                        )
+                        .into());
                     }
 
                     cfg.set_typed(instr_ref, conformed.ty);