Basically revert everything, create macro-pass

reid/src/codegen/allocator.rs

@@ -61,7 +61,6 @@ impl mir::FunctionDefinitionKind {
             }
             mir::FunctionDefinitionKind::Extern(_) => {}
             mir::FunctionDefinitionKind::Intrinsic(_) => {}
-            mir::FunctionDefinitionKind::Macro(_) => {}
         }
 
         Allocator { allocations: allocated }

reid/src/codegen/intrinsics.rs

@@ -310,7 +310,11 @@ pub trait IntrinsicFunction: std::fmt::Debug {
 }
 
 pub trait MacroFunction: std::fmt::Debug {
-    fn codegen<'ctx, 'a>(&self, scope: &mut Scope<'ctx, 'a>, params: &[mir::Literal]) -> Result<StackValue, ErrorKind>;
+    fn generate<'ctx, 'a>(
+        &self,
+        scope: &mut Scope<'ctx, 'a>,
+        params: &[mir::Literal],
+    ) -> Result<mir::Expression, ErrorKind>;
 }
 
 macro_rules! intrinsic_debug {

reid/src/codegen/mod.rs

@@ -237,7 +237,6 @@ impl mir::Module {
                     },
                 )),
                 mir::FunctionDefinitionKind::Intrinsic(_) => None,
-                mir::FunctionDefinitionKind::Macro(_) => None,
             };
 
             if let Some(func) = func {
@@ -290,7 +289,6 @@ impl mir::Module {
                     },
                 )),
                 mir::FunctionDefinitionKind::Intrinsic(_) => None,
-                mir::FunctionDefinitionKind::Macro(_) => None,
             };
 
             if let Some(func) = func {
@@ -377,7 +375,6 @@ impl mir::Module {
                                         }
                                         FunctionDefinitionKind::Extern(_) => None,
                                         FunctionDefinitionKind::Intrinsic(_) => None,
-                                        FunctionDefinitionKind::Macro(_) => None,
                                     },
                                 )
                                 .unwrap();
@@ -398,7 +395,6 @@ impl mir::Module {
                         FunctionDefinitionKind::Intrinsic(intrinsic_function) => {
                             ScopeFunctionKind::Intrinsic(intrinsic_function)
                         }
-                        FunctionDefinitionKind::Macro(macro_function) => ScopeFunctionKind::Macro(macro_function),
                     },
                 },
             );
@@ -455,7 +451,6 @@ impl mir::Module {
                             }
                             FunctionDefinitionKind::Extern(_) => None,
                             FunctionDefinitionKind::Intrinsic(_) => None,
-                            FunctionDefinitionKind::Macro(macro_function) => None,
                         },
                     )
                     .unwrap();
@@ -516,7 +511,6 @@ impl mir::Module {
                             }
                             FunctionDefinitionKind::Extern(_) => None,
                             FunctionDefinitionKind::Intrinsic(_) => None,
-                            FunctionDefinitionKind::Macro(_) => None,
                         },
                     )
                     .unwrap();
@@ -623,7 +617,6 @@ impl FunctionDefinitionKind {
             }
             mir::FunctionDefinitionKind::Extern(_) => {}
             mir::FunctionDefinitionKind::Intrinsic(_) => {}
-            FunctionDefinitionKind::Macro(_) => {}
         };
         Ok(())
     }
@@ -1387,14 +1380,7 @@ fn codegen_function_call<'ctx, 'a>(
             .or(intrinsic.as_ref())
             .expect(&format!("Function {} does not exist!", call_name));
         callee
-            .codegen(
+            .codegen(&call_name, params.as_slice(), &call.return_type, location, scope)
-                &call_name,
-                params.as_slice(),
-                &call.parameters,
-                &call.return_type,
-                location,
-                scope,
-            )
             .unwrap()
     } else {
         let callee = scope
@@ -1403,14 +1389,7 @@ fn codegen_function_call<'ctx, 'a>(
             .expect(&format!("Function {} does not exist!", call_name));
 
         callee
-            .codegen(
+            .codegen(&call_name, params.as_slice(), &call.return_type, location, scope)
-                &call_name,
-                params.as_slice(),
-                &call.parameters,
-                &call.return_type,
-                location,
-                scope,
-            )
             .unwrap()
     };
 

reid/src/codegen/scope.rs

@@ -140,7 +140,6 @@ pub enum ScopeFunctionKind<'ctx> {
     UserGenerated(Function<'ctx>),
     Intrinsic(&'ctx Box<dyn IntrinsicFunction>),
     IntrinsicOwned(Box<dyn IntrinsicFunction>),
-    Macro(&'ctx Box<dyn MacroFunction>),
 }
 
 impl<'ctx> StackBinopDefinition<'ctx> {
@@ -159,7 +158,7 @@ impl<'ctx> StackBinopDefinition<'ctx> {
             "binop.{}.{}.{}.call",
             self.parameters.0.ty, self.parameters.1.ty, self.return_ty
         );
-        self.kind.codegen(&name, &[lhs, rhs], &[], &self.return_ty, None, scope)
+        self.kind.codegen(&name, &[lhs, rhs], &self.return_ty, None, scope)
     }
 }
 
@@ -168,7 +167,6 @@ impl<'ctx> ScopeFunctionKind<'ctx> {
         &self,
         name: &str,
         params: &[StackValue],
-        param_exprs: &[mir::Expression],
         return_ty: &TypeKind,
         location: Option<DebugLocation>,
         scope: &mut Scope<'ctx, 'a>,
@@ -193,16 +191,6 @@ impl<'ctx> ScopeFunctionKind<'ctx> {
             }
             ScopeFunctionKind::Intrinsic(fun) => fun.codegen(scope, params),
             ScopeFunctionKind::IntrinsicOwned(fun) => fun.codegen(scope, params),
-            ScopeFunctionKind::Macro(fun) => fun.codegen(
-                scope,
-                &param_exprs
-                    .iter()
-                    .map(|e| match &e.0 {
-                        crate::mir::ExprKind::Literal(lit) => lit.clone(),
-                        _ => panic!(),
-                    })
-                    .collect::<Vec<_>>(),
-            ),
         }
     }
 }

reid/src/mir/fmt.rs

@@ -151,7 +151,6 @@ impl Display for FunctionDefinitionKind {
             FunctionDefinitionKind::Extern(true) => write!(f, "<Imported Extern>"),
             FunctionDefinitionKind::Extern(false) => write!(f, "<Linked Extern>"),
             FunctionDefinitionKind::Intrinsic(_) => write!(f, "<Intrinsic>"),
-            FunctionDefinitionKind::Macro(_) => write!(f, "<Macro>"),
         }
     }
 }

reid/src/mir/implement.rs

@@ -615,7 +615,6 @@ impl FunctionDefinition {
                 }
             }
             FunctionDefinitionKind::Intrinsic(_) => Err(EqualsIssue::ExistsAsIntrinsic),
-            FunctionDefinitionKind::Macro(_) => Err(EqualsIssue::ExistsAsIntrinsic),
         }
     }
 }

reid/src/mir/linker.rs

@@ -269,7 +269,6 @@ impl<'map> Pass for LinkerPass<'map> {
                             }
                             FunctionDefinitionKind::Extern(_) => {}
                             FunctionDefinitionKind::Intrinsic(_) => {}
-                            FunctionDefinitionKind::Macro(_) => {}
                         }
                     }
 

reid/src/mir/macros.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+use crate::codegen::intrinsics::MacroFunction;
+
+use super::pass::{Pass, PassResult, PassState};
+
+#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ErrorKind {
+    #[error("Should never be encountered!")]
+    Null,
+}
+
+/// Struct used to implement a type-checking pass that can be performed on the
+/// MIR.
+pub struct MacroPass {
+    macros: HashMap<String, Box<dyn MacroFunction>>,
+}
+
+type LinkerPassState<'st, 'sc> = PassState<'st, 'sc, (), ErrorKind>;
+
+impl Pass for MacroPass {
+    type Data = ();
+    type TError = ErrorKind;
+
+    fn expr(&mut self, expr: &mut super::Expression, state: PassState<Self::Data, Self::TError>) -> PassResult {
+        Ok(())
+    }
+}

reid/src/mir/mod.rs

@@ -13,6 +13,7 @@ use crate::{
 mod fmt;
 pub mod implement;
 pub mod linker;
+pub mod macros;
 pub mod pass;
 pub mod typecheck;
 
@@ -322,8 +323,6 @@ pub enum FunctionDefinitionKind {
     Extern(bool),
     /// Intrinsic definition, defined within the compiler
     Intrinsic(Box<dyn IntrinsicFunction>),
-    /// Macro function, executed entirely on the compiler
-    Macro(Box<dyn MacroFunction>),
 }
 
 impl FunctionDefinition {
@@ -332,7 +331,6 @@ impl FunctionDefinition {
             FunctionDefinitionKind::Local(block, _) => block.meta.clone(),
             FunctionDefinitionKind::Extern(_) => Metadata::default(),
             FunctionDefinitionKind::Intrinsic(_) => Metadata::default(),
-            FunctionDefinitionKind::Macro(_) => Metadata::default(),
         }
     }
 
@@ -341,7 +339,6 @@ impl FunctionDefinition {
             FunctionDefinitionKind::Local(_, metadata) => metadata.clone(),
             FunctionDefinitionKind::Extern(_) => Metadata::default(),
             FunctionDefinitionKind::Intrinsic(_) => Metadata::default(),
-            FunctionDefinitionKind::Macro(_) => Metadata::default(),
         }
     }
 }
@@ -406,7 +403,6 @@ impl BinopDefinition {
             FunctionDefinitionKind::Local(block, _) => Some(block.meta),
             FunctionDefinitionKind::Extern(_) => None,
             FunctionDefinitionKind::Intrinsic(_) => None,
-            FunctionDefinitionKind::Macro(_) => None,
         }
     }
 

reid/src/mir/pass.rs

@@ -188,7 +188,6 @@ impl<Data: Clone + Default> Scope<Data> {
                     ScopeFunction {
                         ret: func.return_type,
                         params: func.parameters.iter().map(|p| p.ty.clone()).collect(),
-                        is_macro: matches!(func.kind, FunctionDefinitionKind::Macro(_)),
                     },
                 )
                 .unwrap();
@@ -203,7 +202,6 @@ impl<Data: Clone + Default> Scope<Data> {
 pub struct ScopeFunction {
     pub ret: TypeKind,
     pub params: Vec<TypeKind>,
-    pub is_macro: bool,
 }
 
 #[derive(Clone, Debug)]
@@ -429,7 +427,6 @@ impl Module {
                     ScopeFunction {
                         ret: function.return_type.clone(),
                         params: function.parameters.iter().cloned().map(|v| v.ty).collect(),
-                        is_macro: matches!(function.kind, FunctionDefinitionKind::Macro(_)),
                     },
                 )
                 .ok();
@@ -443,7 +440,6 @@ impl Module {
                     ScopeFunction {
                         ret: function.return_type.clone(),
                         params: function.parameters.iter().cloned().map(|v| v.ty).collect(),
-                        is_macro: matches!(function.kind, FunctionDefinitionKind::Macro(_)),
                     },
                 )
                 .ok();
@@ -488,7 +484,6 @@ impl FunctionDefinition {
             }
             FunctionDefinitionKind::Extern(_) => {}
             FunctionDefinitionKind::Intrinsic(..) => {}
-            FunctionDefinitionKind::Macro(_) => {}
         };
         Ok(())
     }

reid/src/mir/typecheck/typecheck.rs

@@ -194,7 +194,6 @@ impl FunctionDefinitionKind {
             }
             FunctionDefinitionKind::Extern(_) => Ok((ReturnKind::Soft, TypeKind::Vague(Vague::Unknown))),
             FunctionDefinitionKind::Intrinsic(intrinsic) => Ok((ReturnKind::Soft, TypeKind::Vague(Vague::Unknown))),
-            FunctionDefinitionKind::Macro(_) => Ok((ReturnKind::Soft, TypeKind::Vague(Vague::Unknown))),
         }
     }
 }
@@ -472,16 +471,6 @@ impl Expression {
                         );
                     }
 
-                    if f.is_macro {
-                        for param in &function_call.parameters {
-                            match &param.0 {
-                                ExprKind::Literal(_) => {}
-                                _ => return Err(ErrorKind::Null),
-                            }
-                        }
-                        return Ok(function_call.return_type.clone());
-                    }
-
                     let true_params_iter = f
                         .params
                         .into_iter()

reid/src/mir/typecheck/typeinference.rs

@@ -56,7 +56,6 @@ impl<'t> Pass for TypeInference<'t> {
                         FunctionDefinitionKind::Local(..) => ErrorTypedefKind::Local,
                         FunctionDefinitionKind::Extern(..) => ErrorTypedefKind::Extern,
                         FunctionDefinitionKind::Intrinsic(..) => ErrorTypedefKind::Intrinsic,
-                        FunctionDefinitionKind::Macro(..) => ErrorTypedefKind::Intrinsic,
                     },
                 );
             }
@@ -80,7 +79,6 @@ impl<'t> Pass for TypeInference<'t> {
                         FunctionDefinitionKind::Local(..) => ErrorTypedefKind::Local,
                         FunctionDefinitionKind::Extern(..) => ErrorTypedefKind::Extern,
                         FunctionDefinitionKind::Intrinsic(..) => ErrorTypedefKind::Intrinsic,
-                        FunctionDefinitionKind::Macro(..) => ErrorTypedefKind::Intrinsic,
                     },
                 );
             }
@@ -193,7 +191,6 @@ impl FunctionDefinition {
             }
             FunctionDefinitionKind::Extern(_) => {}
             FunctionDefinitionKind::Intrinsic(_) => {}
-            FunctionDefinitionKind::Macro(_) => {}
         };
         let return_ty = self
             .kind
@@ -226,7 +223,6 @@ impl FunctionDefinitionKind {
             }
             FunctionDefinitionKind::Extern(_) => None,
             FunctionDefinitionKind::Intrinsic(_) => None,
-            FunctionDefinitionKind::Macro(_) => todo!(),
         })
     }
 }