Interpreter for validated

compiler/src/interpreter.rs

@@ -1,4 +1,5 @@
 use crate::passes::validate::TLit;
+use crate::utils::gen_sym::UniqueSym;
 use derive_more::Display;
 use std::collections::HashMap;
 use std::fmt::Display;
@@ -41,33 +42,33 @@ impl IO for TestIO {
 }
 
 #[derive(Eq, PartialEq, Clone, Debug, Display)]
-pub enum Val<'p, A: Copy + Hash + Eq + Display> {
+pub enum Val<'p> {
     #[display(fmt = "{val}")]
     Int { val: i64 },
     #[display(fmt = "{}", r#"if *val { "true" } else { "false" }"#)]
     Bool { val: bool },
     #[display(fmt = "unit")]
     Unit,
     #[display(fmt = "fn pointer `{sym}`")]
-    Function { sym: A },
+    Function { sym: UniqueSym<'p> },
+    #[display(fmt = "stdlib function `{sym}`")]
+    StdlibFunction { sym: &'p str, },
     #[display(fmt = "struct instance")]
-    StructInstance {
-        fields: HashMap<&'p str, Val<'p, A>>,
-    },
+    StructInstance { fields: HashMap<&'p str, Val<'p>> },
 }
 
-impl<'p, A: Copy + Hash + Eq + Display> From<TLit> for Val<'p, A> {
+impl<'p> From<TLit> for Val<'p> {
     fn from(value: TLit) -> Self {
         match value {
-            TLit::I64 { val } => Val::Int { val: val },
+            TLit::I64 { val } => Val::Int { val },
             TLit::U64 { val } => Val::Int { val: val as i64 },
             TLit::Bool { val } => Val::Bool { val },
             TLit::Unit => Val::Unit,
         }
     }
 }
 
-impl<'p, A: Copy + Hash + Eq + Display> Val<'p, A> {
+impl<'p> Val<'p> {
     pub fn int(&self) -> i64 {
         match self {
             Val::Int { val } => *val,
@@ -82,14 +83,14 @@ impl<'p, A: Copy + Hash + Eq + Display> Val<'p, A> {
         }
     }
 
-    pub fn fun(&self) -> A {
+    pub fn fun(&self) -> UniqueSym<'p> {
         match self {
             Val::Function { sym } => *sym,
             _ => panic!(),
         }
     }
 
-    pub fn strct(&self) -> &HashMap<&'p str, Val<'p, A>> {
+    pub fn strct(&self) -> &HashMap<&'p str, Val<'p>> {
         match self {
             Val::StructInstance { fields } => fields,
             _ => panic!(),

compiler/src/passes/eliminate/interpret.rs

@@ -42,7 +42,7 @@ impl<'p> EVal<'p> {
     }
 }
 
-impl<'p> From<EVal<'p>> for Val<'p, UniqueSym<'p>> {
+impl<'p> From<EVal<'p>> for Val<'p> {
     fn from(value: EVal<'p>) -> Self {
         match value {
             EVal::Int { val } => Val::Int { val },

compiler/src/passes/explicate/interpret.rs

@@ -6,16 +6,16 @@ use crate::utils::gen_sym::UniqueSym;
 use crate::utils::push_map::PushMap;
 
 impl<'p> PrgExplicated<'p> {
-    pub fn interpret(&self, io: &mut impl IO) -> Val<'p, UniqueSym<'p>> {
+    pub fn interpret(&self, io: &mut impl IO) -> Val<'p> {
         self.interpret_tail(&self.blocks[&self.entry], &mut PushMap::default(), io)
     }
 
     fn interpret_tail(
         &self,
         tail: &CTail<'p>,
-        scope: &mut PushMap<UniqueSym<'p>, Val<'p, UniqueSym<'p>>>,
+        scope: &mut PushMap<UniqueSym<'p>, Val<'p>>,
         io: &mut impl IO,
-    ) -> Val<'p, UniqueSym<'p>> {
+    ) -> Val<'p> {
         match tail {
             CTail::Return { expr, .. } => self.interpret_atom(expr, scope),
             CTail::Seq { sym, bnd, tail } => {
@@ -36,9 +36,9 @@ impl<'p> PrgExplicated<'p> {
     pub fn interpret_expr(
         &self,
         _expr: &CExpr<'p>,
-        _scope: &mut PushMap<UniqueSym<'p>, Val<'p, UniqueSym<'p>>>,
+        _scope: &mut PushMap<UniqueSym<'p>, Val<'p>>,
         _io: &mut impl IO,
-    ) -> Val<'p, UniqueSym<'p>> {
+    ) -> Val<'p> {
         todo!()
         // match expr {
         //     CExpr::Prim { op, args, .. } => match (op, args.as_slice()) {
@@ -168,8 +168,8 @@ impl<'p> PrgExplicated<'p> {
     pub fn interpret_atom(
         &self,
         atom: &Atom<'p>,
-        scope: &PushMap<UniqueSym<'p>, Val<'p, UniqueSym<'p>>>,
-    ) -> Val<'p, UniqueSym<'p>> {
+        scope: &PushMap<UniqueSym<'p>, Val<'p>>,
+    ) -> Val<'p> {
         match atom {
             Atom::Val { val } => (*val).into(),
             Atom::Var { sym } => scope[sym].clone(),

compiler/src/passes/parse/mod.rs

@@ -5,7 +5,6 @@
 #[allow(clippy::all, clippy::pedantic)]
 mod grammar;
 mod display;
-pub mod interpreter;
 pub mod parse;
 #[cfg(test)]
 mod tests;

compiler/src/passes/parse/parse.rs

@@ -1,11 +1,14 @@
 use crate::passes::parse::grammar::ProgramParser;
 use crate::passes::parse::PrgParsed;
+#[cfg(test)]
+use derive_name::VariantName;
 use itertools::Itertools;
 use lalrpop_util::lexer::Token;
 use lalrpop_util::ParseError;
 use miette::Diagnostic;
 use thiserror::Error;
 
+#[cfg_attr(test, derive(VariantName))]
 #[derive(Error, Debug, Diagnostic)]
 pub enum PrettyParseError {
     #[error("Parse error: Invalid token.")]

compiler/src/passes/parse/tests.rs

@@ -1,5 +1,6 @@
 use crate::passes::parse::parse::{parse_program, PrettyParseError};
 use crate::utils::split_test::split_test;
+use derive_name::VariantName;
 use test_each_file::test_each_file;
 
 fn parse([test]: [&str; 1]) {
@@ -9,23 +10,15 @@ fn parse([test]: [&str; 1]) {
 
     match (result, expected_error) {
         (Ok(_), None) => {}
+        (Ok(_), Some(expected_error)) => {
+            panic!("Expected error `{expected_error}`, but succeeded instead.")
+        }
         (Err(error), None) => {
             panic!("Should have succeeded, but panicked with `{error}` instead")
         }
-        (Ok(_), Some(expected_error)) => {
-            panic!("Expected error `{expected_error}`, but succeeded instead.")
+        (Err(error), Some(expected_error)) => {
+            assert_eq!(error.variant_name(), expected_error);
         }
-        (Err(error), Some(expected_error)) => match error {
-            PrettyParseError::InvalidToken { .. } => {
-                assert_eq!(expected_error, "InvalidToken")
-            }
-            PrettyParseError::UnexpectedToken { .. } => {
-                assert_eq!(expected_error, "UnexpectedToken")
-            }
-            PrettyParseError::UnexpectedEOF { .. } => {
-                assert_eq!(expected_error, "UnexpectedEOF")
-            }
-        },
     }
 }