Improved parsing

src/root.rs

@@ -77,8 +77,6 @@ pub fn main_args(args: Args) -> Result<(), WErr> {
         let parsed = parse(PathBuf::from(&args.input))?;
     );
 
-    println!("{:#?}", parsed);
-
     print!("Resolving Names... ");
     time!(
         let (global_table, unprocessed_functions) = resolve(parsed)?;

src/root/parser/parse_arguments.rs

@@ -1,44 +1,36 @@
 use crate::root::parser::parse::{ErrorTree, ParseResult, Span};
-use crate::root::parser::parse_blocks::take_until_discard_smart;
+use crate::root::parser::parse_blocks::{take_until_discard_smart, take_until_or_end_discard_smart};
 use crate::root::parser::parse_function::parse_evaluable::{
     parse_evaluable, EvaluableToken, EvaluableTokens,
 };
 use crate::root::parser::parse_name::SimpleNameToken;
 use nom::bytes::complete::take_until;
 use nom::InputTake;
+use crate::root::parser::parse_util::discard_ignored;
 
 pub fn parse_arguments<'a, 'b>(
     s: Span<'a>,
     containing_class: Option<&'b SimpleNameToken>,
 ) -> ParseResult<'a, (), Vec<EvaluableToken>> {
     let mut s = s;
+    println!("ARGS SPAN - {}", s);
     let mut args = Vec::new();
-    let mut last = false;
 
     loop {
-        // TODO: Account for brackets
-        let (ns, section) = if let Ok((ns, section)) = take_until_discard_smart(s, ",") {
-            (ns, section)
-        } else {
-            last = true;
-            s.take_split(s.len())
-        };
+        let (ns, _) = discard_ignored(s)?;
+        let (ns, section) = take_until_or_end_discard_smart(ns, ",")?;
 
-        let res = parse_evaluable(section, containing_class, false)?.1;
-
-        if matches!(res.token(), EvaluableTokens::None) {
-            if !last {
-                todo!() // Expected evaluable
-            }
-        } else {
-            args.push(res);
+        if section.is_empty() {
+            break;
         }
 
+        let res = parse_evaluable(section, containing_class, false)?.1;
+        args.push(res);
+
         s = ns;
-        if last {
-            break;
-        }
     }
 
+    println!("{}", args.len());
+
     Ok(((), args))
 }

src/root/parser/parse_blocks.rs

@@ -120,7 +120,7 @@ pub fn take_until_or_end_discard_smart<'a>(s: Span<'a>, until: &str) -> ParseRes
     let original = s.clone();
     let mut s = s;
     let mut found = false;
-    while !s.is_empty() {
+    'outer: while !s.is_empty() {
         if let Ok((ns, _)) = tag::<&str, LocatedSpan<&str, &Rc<PathBuf>>, ErrorTree>(until)(s) {
             found = true;
             s = ns;
@@ -132,7 +132,7 @@ pub fn take_until_or_end_discard_smart<'a>(s: Span<'a>, until: &str) -> ParseRes
         for t in &DEFAULT_TERMINATORS {
             if t.opening == c {
                 s = parse_terminator_default_set(s, t)?.0;
-                continue;
+                continue 'outer;
             }
         }
 
@@ -151,7 +151,7 @@ pub fn take_until_or_end_discard_smart<'a>(s: Span<'a>, until: &str) -> ParseRes
 pub fn take_until_discard_smart<'a>(s: Span<'a>, until: &str) -> ParseResult<'a> {
     let original = s.clone();
     let mut s = s;
-    loop {
+    'outer: loop {
         if s.is_empty() {
             return Err(nom::Err::Error(ErrorTree::from_error_kind(
                 original,
@@ -169,7 +169,7 @@ pub fn take_until_discard_smart<'a>(s: Span<'a>, until: &str) -> ParseResult<'a>
         for t in &DEFAULT_TERMINATORS {
             if t.opening == c {
                 s = parse_terminator_default_set(s, t)?.0;
-                continue;
+                continue 'outer;
             }
         }
 

src/root/parser/parse_function/parse_evaluable.rs

@@ -223,7 +223,6 @@ pub fn parse_evaluable<'a, 'b>(
     semicolon_terminated: bool,
 ) -> ParseResult<'a, Span<'a>, EvaluableToken> {
     let mut s = s;
-    println!("{s}");
 
     let mut evaluables = Vec::new();
 
@@ -234,6 +233,16 @@ pub fn parse_evaluable<'a, 'b>(
         // Terminate on semicolon if semicolon terminated
         if semicolon_terminated {
             if let Ok((ns, _)) = char::<_, ErrorTree>(';')(ns) {
+                if evaluables.is_empty() {
+                    return Ok((
+                        ns,
+                        EvaluableToken {
+                            location: Location::from_span(&ns),
+                            token: EvaluableTokens::None,
+                        },
+                    ));
+                }
+
                 s = ns;
                 break;
             }