✨ Use ndc_parser and ndc_lexer crates directly across the codebase

Author: timfennis

Cargo.lock

@@ -1,6 +1,6 @@
 use crate::interpreter::function::{Function, StaticType};
 
-use crate::ast::ResolvedVar;
+use ndc_parser::ResolvedVar;
 use crate::interpreter::value::Value;
 use std::cell::RefCell;
 use std::fmt;

ndc_lib/src/interpreter/environment.rs

@@ -9,10 +9,10 @@
 //! | Backward index | -10 | -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
 //! +----------------+-----+----+----+----+----+----+----+----+----+----+
 
+use ndc_parser::{Expression, ExpressionLocation};
 use super::{EvaluationError, EvaluationResult, IntoEvaluationResult, evaluate_expression};
 use crate::interpreter::environment::Environment;
 use crate::{
-    ast::{Expression, ExpressionLocation},
     interpreter::{function::FunctionCarrier, sequence::Sequence, value::Value},
 };
 use itertools::Itertools;
@@ -300,8 +300,7 @@ pub fn set_at_index(
                 Offset::Range(from_usize, to_usize) => {
                     let tail = list.drain(from_usize..).collect::<Vec<_>>();
 
-                    // TODO: why is this unwrap safe
-                    list.extend(rhs.try_into_iter().unwrap());
+                    list.extend(rhs.try_into_vec().expect("this must succeed, but not sure why").into_iter());
 
                     list.extend_from_slice(&tail[(to_usize - from_usize)..]);
                 }

ndc_lib/src/interpreter/evaluate/index.rs

@@ -1,4 +1,4 @@
-use crate::ast::{
+use ndc_parser::{
     Binding, Expression, ExpressionLocation, ForBody, ForIteration, LogicalOperator, Lvalue,
 };
 use crate::hash_map::HashMap;

ndc_lib/src/interpreter/evaluate/mod.rs

@@ -1,4 +1,4 @@
-use crate::ast::{ExpressionLocation, ResolvedVar};
+use ndc_parser::{ExpressionLocation, ResolvedVar};
 use crate::hash_map::{DefaultHasher, HashMap};
 use crate::interpreter::environment::Environment;
 use crate::interpreter::evaluate::{

ndc_lib/src/interpreter/function.rs

@@ -1,7 +1,7 @@
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use crate::ast::ExpressionLocation;
+use ndc_parser::ExpressionLocation;
 use crate::interpreter::environment::{Environment, InterpreterOutput};
 use crate::interpreter::evaluate::{EvaluationError, evaluate_expression};
 use crate::interpreter::function::FunctionCarrier;
@@ -62,7 +62,7 @@ impl Interpreter {
         input: &str,
     ) -> Result<Vec<ExpressionLocation>, InterpreterError> {
         let tokens = Lexer::new(input).collect::<Result<Vec<TokenLocation>, _>>()?;
-        let mut expressions = crate::ast::Parser::from_tokens(tokens).parse()?;
+        let mut expressions = ndc_parser::Parser::from_tokens(tokens).parse()?;
 
         let checkpoint = self.analyser.checkpoint();
         for e in &mut expressions {
@@ -123,7 +123,7 @@ pub enum InterpreterError {
     #[error("Error while parsing source")]
     Parser {
         #[from]
-        cause: crate::ast::Error,
+        cause: ndc_parser::Error,
     },
     #[error("Error during static analysis")]
     Resolver {

ndc_lib/src/interpreter/mod.rs

@@ -4,7 +4,7 @@ use std::hash::{Hash, Hasher};
 use std::num::TryFromIntError;
 use std::ops::{Add, Div, Mul, Neg, Not, Rem, Sub};
 
-use crate::ast::BinaryOperator;
+use ndc_parser::BinaryOperator;
 use crate::interpreter::evaluate::EvaluationError;
 use crate::interpreter::function::StaticType;
 use crate::interpreter::int::Int;

ndc_lib/src/interpreter/num.rs

@@ -1,4 +1,4 @@
-use crate::ast::{
+use ndc_parser::{
     Binding, Expression, ExpressionLocation, ForBody, ForIteration, Lvalue, ResolvedVar,
 };
 use crate::interpreter::function::StaticType;

ndc_lib/src/interpreter/semantic/analyser.rs

@@ -77,53 +77,6 @@ impl Value {
         }
     }
 
-    // The alternate solution in this SO thread has a nice way to iterate over the contents of a
-    // RefCell but the iterator would not be compatible with non refcell items
-    // https://stackoverflow.com/questions/33541492/returning-iterator-of-a-vec-in-a-refcell
-    //
-    // Note: this method is called `try_into_iter` but it doesn't always create an iterator over
-    //       the original value. In most cases you get an iterator over a copy of the data.
-    #[must_use]
-    #[deprecated = "use try_into_vec"]
-    pub fn try_into_iter(self) -> Option<impl Iterator<Item = Self>> {
-        match self {
-            Self::Sequence(Sequence::List(list)) => match Rc::try_unwrap(list) {
-                // This short circuit is almost certainly wrong because take will panic if list is borrowed
-                Ok(list) => Some(list.into_inner().into_iter()),
-                Err(list) => Some(Vec::clone(&*list.borrow()).into_iter()),
-            },
-            Self::Sequence(Sequence::Tuple(list)) => match Rc::try_unwrap(list) {
-                Ok(list) => Some(list.into_iter()),
-                Err(list) => Some(Vec::clone(&list).into_iter()),
-            },
-            Self::Sequence(Sequence::Map(map, _)) => {
-                let x = map.borrow().keys().cloned().collect_vec().into_iter();
-                Some(x)
-            }
-            Self::Sequence(Sequence::String(string)) => match Rc::try_unwrap(string) {
-                // This implementation is peak retard, we don't want collect_vec here
-                // ^-- WTF: is this comment, we collect_vec here anyways?
-                Ok(string) => Some(
-                    string
-                        .into_inner()
-                        .chars()
-                        .map(Self::from)
-                        .collect_vec()
-                        .into_iter(),
-                ),
-                Err(string) => Some(
-                    string
-                        .borrow()
-                        .chars()
-                        .map(Self::from)
-                        .collect_vec()
-                        .into_iter(),
-                ),
-            },
-            _ => None,
-        }
-    }
-
     pub fn try_into_vec(self) -> Option<Vec<Self>> {
         match self {
             Self::Sequence(Sequence::List(list)) => match Rc::try_unwrap(list) {

ndc_lib/src/interpreter/value.rs

@@ -1,4 +1,3 @@
-pub use ndc_parser as ast;
 mod compare;
 mod hash_map;
 pub mod interpreter;