[refactor] Removed the old environment definition.

Author: rbonifacio

src/ir/ast.rs

@@ -1,116 +1,5 @@
 pub type Name = String;
 
-use nom::IResult;
-use std::collections::HashMap;
-
-#[derive(Debug, PartialEq, Clone)]
-pub struct Frame<A> {
-    pub parent_function: Option<Function>,
-    pub parent_key: Option<(Name, i32)>,
-    pub variables: HashMap<Name, A>,
-    pub tests: HashMap<Name, Function>,
-}
-
-impl<A> Frame<A> {
-    pub fn new(func: Option<Function>, key: Option<(Name, i32)>) -> Frame<A> {
-        let variables: HashMap<Name, A> = HashMap::new();
-        let tests: HashMap<Name, Function> = HashMap::new();
-        return Frame {
-            parent_function: func,
-            parent_key: key,
-            variables,
-            tests,
-        };
-    }
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub struct Environment<A> {
-    pub scope: Function,
-    pub recursion: i32,
-    pub stack: HashMap<(Name, i32), Frame<A>>,
-    pub type_env: HashMap<Name, Vec<ValueConstructor>>,
-}
-
-impl<A> Environment<A> {
-    pub fn new() -> Environment<A> {
-        let frame: Frame<A> = Frame::new(None, None);
-        let scope = Function::new();
-
-        return Environment {
-            scope,
-            recursion: 0,
-            stack: HashMap::from([(("__main__".to_string(), 0), frame)]),
-            type_env: HashMap::new(),
-        };
-    }
-
-    pub fn scope_key(&self) -> (Name, i32) {
-        return (self.scope_name(), self.recursion);
-    }
-
-    pub fn scope_name(&self) -> Name {
-        return self.scope.name.clone();
-    }
-
-    pub fn scope_return(&self) -> Option<&A> {
-        return self.search_frame(self.scope_name());
-    }
-
-    pub fn get_frame(&self, key: (Name, i32)) -> &Frame<A> {
-        return self.stack.get(&key).unwrap();
-    }
-
-    pub fn search_frame(&self, name: Name) -> Option<&A> {
-        return self
-            .stack
-            .get(&self.scope_key())
-            .unwrap()
-            .variables
-            .get(&name);
-    }
-
-    pub fn insert_frame(&mut self, func: Function) -> () {
-        let new_frame: Frame<A> = Frame::new(Some(self.scope.clone()), Some(self.scope_key()));
-
-        self.stack
-            .insert((func.name.clone(), self.scope_key().1 + 1), new_frame);
-        self.scope = func;
-        self.recursion += 1;
-    }
-
-    pub fn remove_frame(&mut self) -> () {
-        let recursion = self.scope_key().1 - 1;
-        self.scope = self
-            .stack
-            .remove(&self.scope_key())
-            .unwrap()
-            .parent_function
-            .unwrap();
-        self.recursion = recursion;
-    }
-
-    pub fn insert_variable(&mut self, name: Name, kind: A) -> () {
-        if let Some(frame) = self.stack.get_mut(&self.scope_key()) {
-            frame.variables.insert(name, kind);
-        }
-    }
-
-    pub fn insert_type(&mut self, name: Name, constructors: Vec<ValueConstructor>) {
-        self.type_env.insert(name, constructors);
-    }
-
-    pub fn get_type(&self, name: &Name) -> Option<&Vec<ValueConstructor>> {
-        self.type_env.get(name)
-    }
-
-    pub fn insert_test(&mut self, name: Name, test: Function) -> () {
-        if let Some(frame) = self.stack.get_mut(&self.scope_key()) {
-            frame.tests.insert(name, test);
-        }
-    }
-}
-
 #[derive(Clone, Debug, PartialEq)]
 pub struct Function {
     pub name: Name,
@@ -145,21 +34,6 @@ impl FormalArgument {
     }
 }
 
-#[derive(Debug, PartialEq, Clone)]
-pub struct TestEnvironment<A> {
-    pub name: Name,
-    pub env: Environment<A>,
-}
-
-impl<A> TestEnvironment<A> {
-    pub fn new() -> TestEnvironment<A> {
-        return TestEnvironment {
-            name: "__test__".to_string(),
-            env: Environment::<A>::new(),
-        };
-    }
-}
-
 #[derive(Clone, Debug, PartialEq)]
 pub enum Type {
     TInteger,
@@ -260,21 +134,4 @@ pub enum Statement {
     FuncDef(Function),
     Return(Box<Expression>),
     TypeDeclaration(Name, Vec<ValueConstructor>),
-}
-
-#[derive(Debug)]
-pub enum ParseError {
-    IndentationError(usize),
-    UnexpectedToken(String),
-    InvalidExpression(String),
-}
-
-pub fn with_error_context<'a, T>(
-    parser: impl Fn(&'a str) -> IResult<&'a str, T>,
-    _context: &'a str,
-) -> impl Fn(&'a str) -> IResult<&'a str, T> {
-    move |input| {
-        parser(input)
-            .map_err(|_| nom::Err::Error(nom::error::Error::new(input, nom::error::ErrorKind::Tag)))
-    }
-}
+}