Refactor parser.rs so it uses RootState::parse; remove module cache logic from shared.rs. (#169)

* Copy more parser.rs logic to shared.rs - cleaning up and properly renaming by the way.

* Move code in shared.rs

* Factor out parser\anystate.rs from parser\shared.rs

* Replace AnyResultWithImportPath with a pair tuple - that allowed to shorten any_states.rs by 33 lines.

* Replace JsonStateWithImportPath with a pair tuple, shaving off few lines of code from shared.rs.

* Factor const_state.rs, json_state.rs, root_state.rs out of shared.rs.

* Correct comments for result pairs in two places (any_state.rs, root_state.rs)

* cargo fmt

* Push module cache processing from shared.rs to parser.rs; use root_state.parse in root_state_parse.

---------

Co-authored-by: Sasha Gil <alexgil@microsoft.com>

Author: sasha-gil

nanvm-lib/src/parser/any_state.rs

@@ -1,9 +1,8 @@
 use super::{
     json_state::JsonState,
-    path::{concat, split},
     shared::{
-        to_js_string, DataType, JsonElement, JsonStackElement, JsonStackObject, ModuleCache,
-        ParseError, ParseResult, ParsingStatus,
+        to_js_string, DataType, JsonElement, JsonStackElement, JsonStackObject, ParseError,
+        ParseResult, ParsingStatus,
     },
 };
 use crate::{
@@ -72,11 +71,9 @@ impl<M: Manager> AnyState<M> {
         self,
         manager: M,
         token: JsonToken,
-        module_cache: &mut ModuleCache<M::Dealloc>,
-        context_path: String,
     ) -> (
         /*any_result:*/ AnyResult<M>,
-        /*import_path:*/ Option<String>,
+        /*module_name:*/ Option<String>,
     ) {
         match self.status {
             ParsingStatus::Initial | ParsingStatus::ObjectColon => {
@@ -90,9 +87,7 @@ impl<M: Manager> AnyState<M> {
             ParsingStatus::ObjectValue => (self.parse_object_next(manager, token), None),
             ParsingStatus::ObjectComma => (self.parse_object_comma(manager, token), None),
             ParsingStatus::ImportBegin => (self.parse_import_begin(token), None),
-            ParsingStatus::ImportValue => {
-                self.parse_import_value(token, module_cache, context_path)
-            }
+            ParsingStatus::ImportValue => self.parse_import_value(token),
             ParsingStatus::ImportEnd => (self.parse_import_end(token), None),
         }
     }
@@ -101,17 +96,15 @@ impl<M: Manager> AnyState<M> {
         self,
         manager: M,
         token: JsonToken,
-        module_cache: &mut ModuleCache<M::Dealloc>,
-        context_path: String,
     ) -> (
         /*json_state:*/ JsonState<M>,
-        /*import_path:*/ Option<String>,
+        /*module_name:*/ Option<String>,
     ) {
-        let (any_result, import_path) = self.parse(manager, token, module_cache, context_path);
-        match import_path {
-            Some(import_path) => {
+        let (any_result, module_name) = self.parse(manager, token);
+        match module_name {
+            Some(module_name) => {
                 if let AnyResult::Continue(state) = any_result {
-                    (JsonState::ParseModule(state), Some(import_path))
+                    (JsonState::ParseModule(state), Some(module_name))
                 } else {
                     panic!("Import path should be returned only with Continue result");
                 }
@@ -150,37 +143,18 @@ impl<M: Manager> AnyState<M> {
     fn parse_import_value(
         self,
         token: JsonToken,
-        module_cache: &mut ModuleCache<M::Dealloc>,
-        context_path: String,
     ) -> (
-        AnyResult<M>,   /*any_result*/
-        Option<String>, /*import_path*/
+        /*any_result:*/ AnyResult<M>,
+        /*module_name:*/ Option<String>,
     ) {
         match token {
-            JsonToken::String(s) => {
-                let import_path = concat(split(&context_path).0, s.as_str());
-                if let Some(any) = module_cache.complete.get(&import_path) {
-                    return (
-                        AnyResult::Continue(AnyState {
-                            status: ParsingStatus::ImportEnd,
-                            current: JsonElement::Any(any.clone()),
-                            ..self
-                        }),
-                        None,
-                    );
-                }
-                if module_cache.progress.contains(&import_path) {
-                    return (AnyResult::Error(ParseError::CircularDependency), None);
-                }
-                module_cache.progress.insert(import_path.clone());
-                (
-                    AnyResult::Continue(AnyState {
-                        status: ParsingStatus::ImportEnd,
-                        ..self
-                    }),
-                    Some(import_path),
-                )
-            }
+            JsonToken::String(s) => (
+                AnyResult::Continue(AnyState {
+                    status: ParsingStatus::ImportEnd,
+                    ..self
+                }),
+                Some(s),
+            ),
             _ => (AnyResult::Error(ParseError::WrongRequireStatement), None),
         }
     }

nanvm-lib/src/parser/const_state.rs

@@ -2,7 +2,6 @@ use super::{
     any_state::{AnyResult, AnyState},
     json_state::JsonState,
     root_state::{RootState, RootStatus},
-    shared::ModuleCache,
 };
 use crate::{mem::manager::Manager, tokenizer::JsonToken};
 
@@ -12,19 +11,13 @@ pub struct ConstState<M: Manager> {
 }
 
 impl<M: Manager> ConstState<M> {
-    pub fn parse(
-        self,
-        manager: M,
-        token: JsonToken,
-        module_cache: &mut ModuleCache<M::Dealloc>,
-        context_path: String,
-    ) -> JsonState<M> {
+    pub fn parse(self, manager: M, token: JsonToken) -> JsonState<M> {
         match token {
             JsonToken::Semicolon => todo!(),
             _ => {
                 // TODO: use import_path in place of _ below to track possible errors -
                 // or provide an explanation on why it's not necessary.
-                let (any_result, _) = self.state.parse(manager, token, module_cache, context_path);
+                let (any_result, _) = self.state.parse(manager, token);
                 match any_result {
                     AnyResult::Continue(state) => JsonState::ParseConst(ConstState {
                         key: self.key,

nanvm-lib/src/parser/json_state.rs

@@ -2,7 +2,7 @@ use super::{
     any_state::AnyState,
     const_state::ConstState,
     root_state::RootState,
-    shared::{ModuleCache, ParseError, ParseResult},
+    shared::{ParseError, ParseResult},
 };
 use crate::{mem::manager::Manager, tokenizer::JsonToken};
 
@@ -19,29 +19,24 @@ impl<M: Manager> JsonState<M> {
         self,
         manager: M,
         token: JsonToken,
-        module_cache: &mut ModuleCache<M::Dealloc>,
-        context_path: String,
     ) -> (
         /*json_state:*/ JsonState<M>,
-        /*import_path:*/ Option<String>,
+        /*import:*/ Option<(/*id:*/ String, /*module:*/ String)>,
     ) {
         if token == JsonToken::NewLine {
             return match self {
-                JsonState::ParseRoot(state) => {
-                    state.parse(manager, token, module_cache, context_path)
-                }
+                JsonState::ParseRoot(state) => state.parse(manager, token),
                 _ => (self, None),
             };
         }
         match self {
-            JsonState::ParseRoot(state) => state.parse(manager, token, module_cache, context_path),
-            JsonState::ParseConst(state) => (
-                state.parse(manager, token, module_cache, context_path),
-                None,
-            ),
+            JsonState::ParseRoot(state) => state.parse(manager, token),
+            JsonState::ParseConst(state) => (state.parse(manager, token), None),
             JsonState::Result(_) => (JsonState::Error(ParseError::UnexpectedToken), None),
             JsonState::ParseModule(state) => {
-                state.parse_for_module(manager, token, module_cache, context_path)
+                let (json_state, _module_name) = state.parse_for_module(manager, token);
+                // TODO: figure out id and use _module_name to return Some in place of None below.
+                (json_state, None)
             }
             _ => (self, None),
         }