From 7dde45956811339a4127a1e09c6dbb6f9cc1e87b Mon Sep 17 00:00:00 2001
From: Robert-M-Lucas <100799838+Robert-M-Lucas@users.noreply.github.com>
Date: Wed, 7 Aug 2024 18:20:55 +0100
Subject: [PATCH] Transitioned to PathStorage for paths

---
 .idea/workspace.xml                      |  29 +++-
 build/out.out                            | Bin 18224 -> 18224 bytes
 main.why                                 |   2 +-
 parse_test.why                           |   3 -
 src/root.rs                              |  18 ++-
 src/root/compiler/compile.rs             |   4 +-
 src/root/compiler/compile_function.rs    |   6 +-
 src/root/compiler/global_tracker.rs      |  18 ++-
 src/root/errors/mod.rs                   |  33 +++-
 src/root/name_resolver/name_resolvers.rs |  23 +--
 src/root/parser/handle_errors.rs         |  13 +-
 src/root/parser/location.rs              |  59 +++++--
 src/root/parser/mod.rs                   |   1 +
 src/root/parser/parse.rs                 |  27 ++--
 src/root/parser/parse_blocks.rs          |   4 +-
 src/root/parser/path_storage.rs          | 187 +++++++++++++++++++++++
 src/root/parser/use_parser.rs            |  29 +---
 src/root/utils/identify_first_last.rs    |  68 +++++++++
 src/root/{utils.rs => utils/mod.rs}      |  15 +-
 todo.txt                                 |   3 +
 20 files changed, 434 insertions(+), 108 deletions(-)
 delete mode 100644 parse_test.why
 create mode 100644 src/root/parser/path_storage.rs
 create mode 100644 src/root/utils/identify_first_last.rs
 rename src/root/{utils.rs => utils/mod.rs} (86%)

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 02389cb..289bcb7 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -8,8 +8,24 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="6ca282eb-dc8c-4af0-945c-cd77d70c6194" name="Changes" comment="Fmt">
+      <change afterPath="$PROJECT_DIR$/src/root/parser/path_storage.rs" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/root/utils/identify_first_last.rs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/parser/use_parser.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/use_parser.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/build/out.asm" beforeDir="false" afterPath="$PROJECT_DIR$/build/out.asm" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/build/out.o" beforeDir="false" afterPath="$PROJECT_DIR$/build/out.o" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/build/out.out" beforeDir="false" afterPath="$PROJECT_DIR$/build/out.out" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/parse_test.why" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/compiler/compile.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/compile.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/compiler/compile_function.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/compile_function.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/compiler/global_tracker.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/global_tracker.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/errors/mod.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/errors/mod.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/name_resolver/name_resolvers.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/name_resolver/name_resolvers.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/handle_errors.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/handle_errors.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/location.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/location.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/mod.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/mod.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/utils.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/utils/mod.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/todo.txt" beforeDir="false" afterPath="$PROJECT_DIR$/todo.txt" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -66,7 +82,7 @@
   <component name="GithubPullRequestsUISettings"><![CDATA[{
   "selectedUrlAndAccountId": {
     "url": "https://github.com/Robert-M-Lucas/whython-8.git",
-    "accountId": "4a322597-eb99-4adb-939a-37a7436c8242"
+    "accountId": "dcb8df19-0b39-47e1-9073-4a54f7034be8"
   }
 }]]></component>
   <component name="MacroExpansionManager">
@@ -122,13 +138,17 @@
       <recent name="$PROJECT_DIR$/src/root/builtin/types" />
     </key>
     <key name="MoveFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/src/root/utils" />
+      <recent name="$PROJECT_DIR$/src/root" />
       <recent name="$PROJECT_DIR$/std" />
       <recent name="C:\Users\rober\Documents\Coding\RustProjects\whython-8\src\root\compiler\evaluation" />
       <recent name="$PROJECT_DIR$/src/root/builtin/types/int" />
-      <recent name="$PROJECT_DIR$/src/root/builtin/types" />
-      <recent name="$PROJECT_DIR$/src/root/builtin/int" />
     </key>
   </component>
+  <component name="RsExternalLinterProjectSettings">
+    <option name="runOnTheFly" value="true" />
+    <option name="tool" value="Clippy" />
+  </component>
   <component name="RunManager" selected="Cargo.Run whython-8">
     <configuration name="Run whython-8" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
       <option name="command" value="run --package whython-8 --bin whython-8" />
@@ -271,6 +291,7 @@
       <workItem from="1722625341403" duration="1505000" />
       <workItem from="1722969496898" duration="697000" />
       <workItem from="1723026258349" duration="1557000" />
+      <workItem from="1723045013060" duration="4160000" />
     </task>
     <task id="LOCAL-00031" summary="Cargo fix">
       <option name="closed" value="true" />
diff --git a/build/out.out b/build/out.out
index 9ce01ed7f7d12de62e07d26c02c4fe39378a1b8b..c517ce43ecbd80d22c8a268452dde4885b00ea48 100755
GIT binary patch
delta 116
zcmdnc$G8EAGMGi$7My>5;)A_V!ls9ljhG()+QZ;&zqy8ayUyf9195YAXJ;z~4R^m#
zO$9>}JtI9s1tS9^69WqaLj{eX)D#7e#1g24uAwG_W0;jmfuWJ9`Q%0e8D?_>!^sOE
K^yd8rg<=3}J0w2<

delta 93
zcmdnc$G8EAGMGiG=5@X0PG@)iUd67M71sS*vxnov<{IYhI$~x<1_~NMsVNE`i6sh#
rCVGZ?hPq~&lcf#xIUU2SObQH*%nT+s8ptpM6;56Np*Qb0C=>$#-7*~^

diff --git a/main.why b/main.why
index affe3c4..85502e7 100644
--- a/main.why
+++ b/main.why
@@ -1,4 +1,4 @@
-use std/linked_list;
+use std/linked_list.why;
 
 
 fn main() -> int {
diff --git a/parse_test.why b/parse_test.why
deleted file mode 100644
index 08c40b8..0000000
--- a/parse_test.why
+++ /dev/null
@@ -1,3 +0,0 @@
-fn main() -> int {
-    printb(true, false);
-}
\ No newline at end of file
diff --git a/src/root.rs b/src/root.rs
index 41b3475..e6e7cb9 100644
--- a/src/root.rs
+++ b/src/root.rs
@@ -1,5 +1,5 @@
 use crate::root::compiler::compile::compile;
-use crate::root::errors::WErr;
+use crate::root::errors::{WErr, WErrContext};
 use crate::root::name_resolver::resolve::resolve;
 use crate::root::parser::parse::parse;
 use crate::root::runner::{assemble, link_gcc, run};
@@ -13,6 +13,7 @@ use std::fs::File;
 use std::io::ErrorKind;
 use std::path::PathBuf;
 use std::time::Instant;
+use crate::root::parser::path_storage::PathStorage;
 
 #[cfg(debug_assertions)]
 pub const DEBUG_ON_ERROR: bool = false;
@@ -53,7 +54,7 @@ pub fn main() {
     }
 }
 
-pub fn main_args(args: Args) -> Result<(), WErr> {
+pub fn main_args(args: Args) -> Result<(), String> {
     if let Some(path) = PathBuf::from(&args.output).parent() {
         if let Err(e) = fs::create_dir_all(path) {
             if !matches!(e.kind(), ErrorKind::AlreadyExists) {
@@ -63,19 +64,24 @@ pub fn main_args(args: Args) -> Result<(), WErr> {
         }
     }
 
-    print!("Parsing... ");
+    
+    print!("Parsing files... ");
     time!(
-        let parsed = parse(PathBuf::from(&args.input))?;
+        let mut path_storage = PathStorage::new(&args.input).unwrap(); // TODO: 
+        let toplevel_tokens = parse(&mut path_storage)
+            .map_err(|e| e.with_context(&path_storage).to_string())?;
     );
 
     print!("Resolving Names... ");
     time!(
-        let (global_table, unprocessed_functions) = resolve(parsed)?;
+        let (global_table, unprocessed_functions) = resolve(toplevel_tokens)
+        .map_err(|e| e.with_context(&path_storage).to_string())?;
     );
 
     print!("Compiling... ");
     time!(
-        let assembly = compile(global_table, unprocessed_functions)?;
+        let assembly = compile(global_table, unprocessed_functions, &path_storage)
+            .map_err(|e| e.with_context(&path_storage).to_string())?;
     );
 
     print!("Writing Assembly... ");
diff --git a/src/root/compiler/compile.rs b/src/root/compiler/compile.rs
index 790f566..e4705d0 100644
--- a/src/root/compiler/compile.rs
+++ b/src/root/compiler/compile.rs
@@ -8,6 +8,7 @@ use crate::root::compiler::global_tracker::GlobalTracker;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::GlobalDefinitionTable;
 use crate::root::parser::parse_function::FunctionToken;
+use crate::root::parser::path_storage::PathStorage;
 use crate::root::shared::common::FunctionID;
 use crate::root::unrandom::{new_hashmap, new_hashset};
 
@@ -15,6 +16,7 @@ use crate::root::unrandom::{new_hashmap, new_hashset};
 pub fn compile(
     mut global_table: GlobalDefinitionTable,
     unprocessed_functions: HashMap<FunctionID, FunctionToken>,
+    path_storage: &PathStorage
 ) -> Result<String, WErr> {
     let mut unprocessed_functions = unprocessed_functions;
     let mut compiled_functions = new_hashmap();
@@ -22,7 +24,7 @@ pub fn compile(
 
     let mut open_set = new_hashset();
     open_set.insert(FunctionID(0)); // Start with main
-    let mut global_tracker = GlobalTracker::default();
+    let mut global_tracker = GlobalTracker::new(path_storage);
 
     while !open_set.is_empty() {
         global_tracker.reset_functions();
diff --git a/src/root/compiler/compile_function.rs b/src/root/compiler/compile_function.rs
index 788f7ec..84fc6ab 100644
--- a/src/root/compiler/compile_function.rs
+++ b/src/root/compiler/compile_function.rs
@@ -308,7 +308,11 @@ fn recursively_compile_lines(
                 contents.line("ret");
 
                 if line_i != lines.len() - 1 {
-                    warn(&format!("Return isn't the last instruction in the block. Following lines in block will not be compiled/run.\n{}", rt.location().clone().into_warning()))
+                    warn(
+                        &format!("Return isn't the last instruction in the block. Following lines in block will not be compiled/run.\n{}", 
+                                 rt.location().clone().into_warning().with_context(global_tracker.path_storage())
+                        )
+                    )
                 }
                 break;
             }
diff --git a/src/root/compiler/global_tracker.rs b/src/root/compiler/global_tracker.rs
index f358b69..b350e7c 100644
--- a/src/root/compiler/global_tracker.rs
+++ b/src/root/compiler/global_tracker.rs
@@ -1,17 +1,29 @@
 use crate::root::shared::common::FunctionID;
 use derive_getters::{Dissolve, Getters};
 use std::collections::HashSet;
+use crate::root::parser::path_storage::PathStorage;
 
 /// Tracks data between function compilations
-#[derive(Default, Dissolve, Getters)]
-pub struct GlobalTracker {
+#[derive(Dissolve, Getters)]
+pub struct GlobalTracker<'a> {
+    path_storage: &'a PathStorage,
     function_calls: HashSet<FunctionID>,
     readonly_contents: HashSet<String>,
     readonly_data_section: String,
     unique_tag_counter: usize,
 }
 
-impl GlobalTracker {
+impl<'a> GlobalTracker<'a> {
+    pub fn new(path_storage: &'a PathStorage) -> GlobalTracker {
+        GlobalTracker {
+            path_storage,
+            function_calls: Default::default(),
+            readonly_contents: Default::default(),
+            readonly_data_section: "".to_string(),
+            unique_tag_counter: 0,
+        }
+    }
+    
     pub fn functions_mut(&mut self) -> &mut HashSet<FunctionID> {
         &mut self.function_calls
     }
diff --git a/src/root/errors/mod.rs b/src/root/errors/mod.rs
index 1000c17..46091f8 100644
--- a/src/root/errors/mod.rs
+++ b/src/root/errors/mod.rs
@@ -1,16 +1,19 @@
-use crate::root::parser::location::Location;
+use crate::root::parser::location::{ErrorL, Location, LocationTyped};
 #[cfg(debug_assertions)]
 use crate::root::DEBUG_ON_ERROR;
 use color_print::cformat;
 #[cfg(debug_assertions)]
 use std::backtrace::Backtrace;
 use std::fmt::{Display, Formatter};
+use crate::root::parser::path_storage::PathStorage;
 
 pub mod evaluable_errors;
 pub mod name_resolver_errors;
 pub mod parser_errors;
 
+
 /// Universal error for Whython-8
+#[derive(Debug)]
 pub struct WErr {
     error: String,
     location: Option<Location>, // ! Important, don't do file reads unless necessary (i.e. Display)
@@ -27,8 +30,8 @@ impl WErr {
         };
         #[cfg(debug_assertions)]
         if DEBUG_ON_ERROR {
+            println!("WErr created:");
             println!("{}", Backtrace::capture());
-            println!("\n{w}");
         }
         w
     }
@@ -43,8 +46,8 @@ impl WErr {
         };
         #[cfg(debug_assertions)]
         if DEBUG_ON_ERROR {
+            println!("WErr created:");
             println!("{}", Backtrace::capture());
-            println!("\n{w}");
         }
         Err(w)
     }
@@ -64,15 +67,31 @@ impl WErr {
             location: None,
         }
     }
-}
 
-impl Display for WErr {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    pub fn with_context<'a>(&'a self, path_storage: &'a PathStorage) -> WErrContext {
+        WErrContext {
+            err: self,
+            path_storage,
+        }
+    }
+
+    fn fmt(&self, f: &mut Formatter<'_>, path_storage: &PathStorage) -> std::fmt::Result {
         let text = if let Some(location) = &self.location {
-            cformat!("<r,bold>Error:</>\n    {}\n{}\n", self.error, location)
+            cformat!("<r,bold>Error:</>\n    {}\n{}\n", self.error, location.with_context(path_storage))
         } else {
             cformat!("<r,bold>Error:</>\n    {}", self.error)
         };
         f.write_str(&text)
     }
 }
+
+pub struct WErrContext<'a> {
+    err: &'a WErr,
+    path_storage: &'a PathStorage
+}
+
+impl<'a> Display for WErrContext<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.err.fmt(f, self.path_storage)
+    }
+}
\ No newline at end of file
diff --git a/src/root/name_resolver/name_resolvers.rs b/src/root/name_resolver/name_resolvers.rs
index 34c91af..05cdeef 100644
--- a/src/root/name_resolver/name_resolvers.rs
+++ b/src/root/name_resolver/name_resolvers.rs
@@ -19,6 +19,7 @@ use crate::root::POINTER_SIZE;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::rc::Rc;
+use crate::root::parser::path_storage::FileID;
 
 #[derive(Debug)]
 enum NameTreeEntry {
@@ -45,16 +46,16 @@ impl NameTree {
 /// Top level of tree containing all named objects/functions/types
 #[derive(Default)]
 struct TopLevelNameTree {
-    table: HashMap<Rc<PathBuf>, NameTree>,
+    table: HashMap<FileID, NameTree>,
 }
 
 impl TopLevelNameTree {
-    pub fn get_tree_mut(&mut self, path: Rc<PathBuf>) -> &mut NameTree {
-        if !self.table.contains_key(&path) {
-            self.table.insert(path.clone(), Default::default());
+    pub fn get_tree_mut(&mut self, file_id: FileID) -> &mut NameTree {
+        if !self.table.contains_key(&file_id) {
+            self.table.insert(file_id, Default::default());
         }
 
-        self.table.get_mut(&path).unwrap()
+        self.table.get_mut(&file_id).unwrap()
     }
 }
 
@@ -161,7 +162,7 @@ impl GlobalDefinitionTable {
         // TODO
         let file_level_tree = self
             .name_table
-            .get_tree_mut(st.location().path().unwrap().clone());
+            .get_tree_mut(st.location().file_id().unwrap());
         self.id_counter += 1;
         let id = TypeID(self.id_counter - 1);
 
@@ -196,7 +197,7 @@ impl GlobalDefinitionTable {
             // TODO
             let file_level_tree = self
                 .name_table
-                .get_tree_mut(ft.location().path().unwrap().clone());
+                .get_tree_mut(ft.location().file_id().unwrap());
             file_level_tree.add_entry(ft.name().name().clone(), NameTreeEntry::Function(id));
         }
 
@@ -275,7 +276,7 @@ impl GlobalDefinitionTable {
         // TODO
         if let Some(r) = process_tree(
             self.name_table
-                .get_tree_mut(full_name.location().path().unwrap().clone()),
+                .get_tree_mut(full_name.location().file_id().unwrap()),
         ) {
             return r;
         }
@@ -284,7 +285,7 @@ impl GlobalDefinitionTable {
             .name_table
             .table
             .iter()
-            .filter(|(p, _)| *p != full_name.location().path().unwrap())
+            .filter(|(p, _)| **p != full_name.location().file_id().unwrap())
         {
             if let Some(r) = process_tree(tree) {
                 return r;
@@ -401,7 +402,7 @@ impl GlobalDefinitionTable {
         // TODO
         if let Some(r) = process_tree(
             self.name_table
-                .get_tree_mut(name.location().path().unwrap().clone()),
+                .get_tree_mut(name.location().file_id().unwrap()),
         ) {
             return r;
         }
@@ -411,7 +412,7 @@ impl GlobalDefinitionTable {
             .name_table
             .table
             .iter()
-            .filter(|(p, _)| *p != name.location().path().unwrap())
+            .filter(|(p, _)| **p != name.location().file_id().unwrap())
         {
             if let Some(r) = process_tree(tree) {
                 return r;
diff --git a/src/root/parser/handle_errors.rs b/src/root/parser/handle_errors.rs
index 3c7263f..d378c9d 100644
--- a/src/root/parser/handle_errors.rs
+++ b/src/root/parser/handle_errors.rs
@@ -4,8 +4,9 @@ use crate::root::errors::parser_errors::ParseError;
 use crate::root::errors::WErr;
 use crate::root::parser::location::Location;
 use crate::root::parser::parse::{ErrorTree, ParseResult};
+use crate::root::parser::path_storage::PathStorage;
 
-pub fn handle_error<A, B>(res: ParseResult<A, B>) -> Result<(A, B), WErr> {
+pub fn handle_error<A, B>(res: ParseResult<A, B>, path_storage: &PathStorage) -> Result<(A, B), WErr> {
     match res {
         Ok(v) => Ok(v),
         Err(e) => match &e {
@@ -13,12 +14,12 @@ pub fn handle_error<A, B>(res: ParseResult<A, B>) -> Result<(A, B), WErr> {
                 ParseError::ParserIncompleteErrorsNotImplemented, // TODO
                 Location::builtin(),
             ),
-            nom::Err::Error(y) | nom::Err::Failure(y) => Err(handle_error_tree(y)),
+            nom::Err::Error(y) | nom::Err::Failure(y) => Err(handle_error_tree(y, path_storage)),
         },
     }
 }
 
-fn handle_error_tree(e: &ErrorTree) -> WErr {
+fn handle_error_tree(e: &ErrorTree, path_storage: &PathStorage) -> WErr {
     match e {
         ErrorTree::Base { location, kind } => match kind {
             BaseErrorKind::Expected(smth) => WErr::n(
@@ -33,7 +34,7 @@ fn handle_error_tree(e: &ErrorTree) -> WErr {
         },
         ErrorTree::Stack { base, contexts } => {
             let mut sb = "Base Error:\n".to_string();
-            for l in handle_error_tree(base).to_string().lines() {
+            for l in handle_error_tree(base, path_storage).with_context(path_storage).to_string().lines() {
                 sb += "     ";
                 sb += l;
                 sb += "\n";
@@ -47,7 +48,7 @@ fn handle_error_tree(e: &ErrorTree) -> WErr {
                     StackContext::Context(c) => c.to_string(),
                 };
 
-                for l in WErr::n(e, Location::from_span(s)).to_string().lines() {
+                for l in WErr::n(e, Location::from_span(s)).with_context(path_storage).to_string().lines() {
                     sb += "    ";
                     sb += l;
                     sb += "\n";
@@ -62,7 +63,7 @@ fn handle_error_tree(e: &ErrorTree) -> WErr {
             for (i, e) in z.iter().enumerate() {
                 sb += &format!("{}:\n", i + 1);
 
-                let werr = handle_error_tree(e).to_string();
+                let werr = handle_error_tree(e, path_storage).with_context(path_storage).to_string();
                 for line in werr.lines() {
                     sb += "    ";
                     sb += line;
diff --git a/src/root/parser/location.rs b/src/root/parser/location.rs
index ab9ec3b..df0f3fc 100644
--- a/src/root/parser/location.rs
+++ b/src/root/parser/location.rs
@@ -7,6 +7,7 @@ use std::fs;
 use std::marker::PhantomData;
 use std::path::PathBuf;
 use std::rc::Rc;
+use crate::root::parser::path_storage::{FileID, PathStorage};
 
 pub enum ToLocation<'a> {
     Location(Location),
@@ -32,8 +33,8 @@ impl<'a> ToLocation<'a> {
 
 #[derive(Debug, Clone, Hash)]
 struct InnerLocation {
-    /// Path of file
-    path: Rc<PathBuf>,
+    /// File id
+    file_id: FileID,
     /// Offset in the line, counted from 0
     offset: usize,
     /// Line number, counted from 1
@@ -56,7 +57,7 @@ enum ErrorLocation {
 }
 
 #[derive(Debug, Clone, Hash)]
-pub struct LocationTyped<ErrorType = ErrorL> {
+pub struct LocationTyped<ErrorType> {
     error_type: PhantomData<ErrorType>,
     inner_location: ErrorLocation,
 }
@@ -75,7 +76,7 @@ impl<ErrorType> LocationTyped<ErrorType> {
         LocationTyped {
             error_type: Default::default(),
             inner_location: ErrorLocation::Location(InnerLocation {
-                path: span.extra.clone(),
+                file_id: span.extra,
                 offset: span.location_offset(),
                 line: span.location_line(),
             }),
@@ -88,21 +89,28 @@ impl<ErrorType> LocationTyped<ErrorType> {
         LocationTyped {
             error_type: Default::default(),
             inner_location: ErrorLocation::Location(InnerLocation {
-                path: span.extra.clone(),
+                file_id: span.extra,
                 offset: span.location_offset(),
                 line: span.location_line(),
             }),
         }
     }
 
-    pub fn path(&self) -> Option<&Rc<PathBuf>> {
+    pub fn file_id(&self) -> Option<FileID> {
         match &self.inner_location {
-            ErrorLocation::Location(l) => Some(&l.path),
+            ErrorLocation::Location(l) => Some(l.file_id),
             ErrorLocation::Builtin => None,
             ErrorLocation::None => None,
         }
     }
 
+    pub fn with_context<'a>(&'a self, path_storage: &'a PathStorage) -> LocationContext<'a, ErrorType> {
+        LocationContext {
+            location: self,
+            path_storage
+        }
+    }
+
     pub fn builtin() -> LocationTyped<ErrorType> {
         LocationTyped {
             error_type: Default::default(),
@@ -121,7 +129,7 @@ impl<ErrorType> LocationTyped<ErrorType> {
         !matches!(self.inner_location, ErrorLocation::None)
     }
 
-    fn fmt_choice(&self, f: &mut Formatter<'_>, is_warning: bool) -> std::fmt::Result {
+    fn fmt_choice(&self, f: &mut Formatter<'_>, is_warning: bool, path_storage: &PathStorage) -> std::fmt::Result {
         let location = match &self.inner_location {
             ErrorLocation::Builtin => {
                 writeln!(f, "{}", cformat!("<c,bold>Builtin Definition</>"))?;
@@ -135,14 +143,14 @@ impl<ErrorType> LocationTyped<ErrorType> {
         };
 
         writeln!(f, "{}", cformat!("<c,bold>In File:</>"))?;
-        writeln!(f, "    {}", location.path.as_path().to_string_lossy())?;
+        writeln!(f, "    {}", path_storage.reconstruct_file(location.file_id))?;
         writeln!(f, "{}", cformat!("<c,bold>At:</>"))?;
 
         fn fail(f: &mut Formatter<'_>) -> std::fmt::Result {
             write!(f, "Failed to fetch file reference (has the file changed?)")
         }
 
-        let Ok(file) = fs::read_to_string(location.path.as_path()) else {
+        let Ok(file) = fs::read_to_string(path_storage.reconstruct_file(location.file_id)) else {
             return fail(f);
         };
 
@@ -280,14 +288,35 @@ impl<ErrorType> LocationTyped<ErrorType> {
 
 const CHAR_LIMIT: usize = 61;
 
-impl Display for LocationTyped<ErrorL> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.fmt_choice(f, false)
+pub trait LocationFilledFmt {
+    fn fmt(&self, f: &mut Formatter<'_>, path_storage: &PathStorage) -> std::fmt::Result;
+}
+
+impl LocationFilledFmt for LocationTyped<ErrorL> {
+    fn fmt(&self, f: &mut Formatter<'_>, path_storage: &PathStorage) -> std::fmt::Result {
+        self.fmt_choice(f, false, path_storage)
+    }
+}
+
+impl LocationFilledFmt for LocationTyped<WarningL> {
+    fn fmt(&self, f: &mut Formatter<'_>, path_storage: &PathStorage) -> std::fmt::Result {
+        self.fmt_choice(f, true, path_storage)
     }
 }
 
-impl Display for LocationTyped<WarningL> {
+pub struct LocationContext<'a, ErrorType> {
+    location: &'a LocationTyped<ErrorType>,
+    path_storage: &'a PathStorage
+}
+
+impl<'a> Display for LocationContext<'a, ErrorL> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.fmt_choice(f, true)
+        self.location.fmt(f, self.path_storage)
     }
 }
+
+impl<'a> Display for LocationContext<'a, WarningL> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.location.fmt(f, self.path_storage)
+    }
+}
\ No newline at end of file
diff --git a/src/root/parser/mod.rs b/src/root/parser/mod.rs
index d8e9c0e..8f20d65 100644
--- a/src/root/parser/mod.rs
+++ b/src/root/parser/mod.rs
@@ -14,3 +14,4 @@ pub mod parse_toplevel;
 pub mod parse_util;
 pub mod soft_alt;
 mod use_parser;
+pub mod path_storage;
diff --git a/src/root/parser/parse.rs b/src/root/parser/parse.rs
index f74134b..404b8b9 100644
--- a/src/root/parser/parse.rs
+++ b/src/root/parser/parse.rs
@@ -1,5 +1,5 @@
 use std::fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::rc::Rc;
 
 use nom::IResult;
@@ -12,34 +12,35 @@ use crate::root::parser::handle_errors::handle_error;
 use crate::root::parser::location::Location;
 use crate::root::parser::parse_toplevel;
 use crate::root::parser::parse_toplevel::TopLevelTokens;
+use crate::root::parser::path_storage::{FileID, PathStorage};
 use crate::root::parser::use_parser::parse_uses;
 
-pub type Span<'a> = LocatedSpan<&'a str, &'a Rc<PathBuf>>;
+pub type Span<'a> = LocatedSpan<&'a str, FileID>;
 
 pub type ParseResult<'a, I = Span<'a>, O = Span<'a>, E = ErrorTree<'a>> = IResult<I, O, E>;
 pub type ErrorTree<'a> = GenericErrorTree<Span<'a>, &'static str, &'static str, String>;
 
-pub fn parse(path: PathBuf) -> Result<Vec<TopLevelTokens>, WErr> {
-    let mut path_queue = vec![(path, Location::builtin())];
+pub fn parse(path_storage: &mut PathStorage) -> Result<Vec<TopLevelTokens>, WErr> {
+    let mut path_queue = vec![(FileID::main_file(), Location::builtin())];
     let mut output = Vec::new();
 
-    while let Some((path, location)) = path_queue.pop() {
-        print!("\n  - {}", path.display());
-        let Ok(text) = fs::read_to_string(path.as_path()) else {
+    while let Some((file_id, location)) = path_queue.pop() {
+        let reconstructed = path_storage.reconstruct_file(file_id);
+        print!("\n  - {}", &reconstructed);
+        let Ok(text) = fs::read_to_string(Path::new(&reconstructed)) else {
             return WErr::ne(
-                ParseError::FailedToOpenFile(format!("{}", path.display())),
+                ParseError::FailedToOpenFile(format!("{}", reconstructed)),
                 location,
             );
         };
 
-        let path = Rc::new(path);
-        let base = Span::new_extra(&text, &path);
+        let base = Span::new_extra(&text, file_id);
 
-        let (after_use, found_paths) = handle_error(parse_uses(base))?;
-        path_queue.extend(found_paths);
+        let (after_use, new_files) = handle_error(parse_uses(base, path_storage), &path_storage)?;
+        path_queue.extend(new_files);
 
         let res = parse_toplevel::parse_toplevel(after_use);
-        let (remaining, new_output) = handle_error(res)?;
+        let (remaining, new_output) = handle_error(res, &path_storage)?;
         debug_assert!(remaining.is_empty());
         output.extend(new_output);
     }
diff --git a/src/root/parser/parse_blocks.rs b/src/root/parser/parse_blocks.rs
index 9121f9b..2374a65 100644
--- a/src/root/parser/parse_blocks.rs
+++ b/src/root/parser/parse_blocks.rs
@@ -126,7 +126,7 @@ pub fn take_until_or_end_discard_smart<'a>(s: Span<'a>, until: &str) -> ParseRes
     let mut s = s;
     let mut found = false;
     'outer: while !s.is_empty() {
-        if let Ok((ns, _)) = tag::<&str, LocatedSpan<&str, &Rc<PathBuf>>, ErrorTree>(until)(s) {
+        if let Ok((ns, _)) = tag::<_, _, ErrorTree>(until)(s) {
             found = true;
             s = ns;
             break;
@@ -165,7 +165,7 @@ pub fn take_until_discard_smart<'a>(s: Span<'a>, until: &str) -> ParseResult<'a>
             )));
         }
 
-        if let Ok((ns, _)) = tag::<&str, LocatedSpan<&str, &Rc<PathBuf>>, ErrorTree>(until)(s) {
+        if let Ok((ns, _)) = tag::<_, _, ErrorTree>(until)(s) {
             s = ns;
             break;
         }
diff --git a/src/root/parser/path_storage.rs b/src/root/parser/path_storage.rs
new file mode 100644
index 0000000..27f1ff2
--- /dev/null
+++ b/src/root/parser/path_storage.rs
@@ -0,0 +1,187 @@
+use std::collections::{HashMap, HashSet};
+use std::fmt::{Display, Formatter};
+use nom::character::complete::anychar;
+use crate::root::errors::parser_errors::{create_custom_error, create_custom_error_tree};
+use crate::root::errors::WErr;
+use crate::root::parser::location::{Location, LocationFilledFmt};
+use crate::root::parser::parse::{ErrorTree, ParseResult, Span};
+use crate::root::utils::identify_first_last::{IdentifyFirstLast, IdentifyLast};
+
+#[derive(Hash, Copy, Clone, Debug, Eq, PartialEq)]
+pub struct FileID(usize);
+
+impl FileID {
+    pub fn main_file() -> FileID { FileID(0) }    
+}
+
+#[derive(Hash, Copy, Clone, Debug, Eq, PartialEq)]
+pub struct FolderID(usize);
+
+struct CodeFolder {
+    parent: FolderID,
+    child_folders: HashMap<String, FolderID>,
+    child_files: HashMap<String, FileID>,
+    current: String
+}
+
+impl CodeFolder {
+    pub fn root() -> CodeFolder {
+        CodeFolder {
+            parent: FolderID(0),
+            child_folders: Default::default(),
+            child_files: Default::default(),
+            current: "[ROOT]".to_string(),
+        }
+    }
+}
+
+
+
+struct CodeFile {
+    parent: FolderID,
+    current: String,
+    use_files: Vec<FileID>,
+    use_folders: Vec<FolderID>,
+}
+
+pub struct PathStorage {
+    folders: Vec<CodeFolder>,
+    files: Vec<CodeFile>
+}
+
+impl PathStorage {
+    pub fn new(base: &str) -> Result<PathStorage, WErr> {
+        // TODO: Only allow certain characters in base
+        let mut folders = vec![CodeFolder::root()];
+        let mut files = Vec::new();
+        
+        let mut current = FolderID(0);
+        for (is_last, section) in base.split('/').identify_last() {
+            if is_last {
+                files.push(CodeFile { 
+                    parent: current, 
+                    current: section.to_string(),
+                    use_files: vec![],
+                    use_folders: vec![],
+                });
+            }
+            else {
+                folders.push(CodeFolder {
+                    parent: current,
+                    child_folders: Default::default(),
+                    child_files: Default::default(),
+                    current: section.to_string(),
+                });
+                current = FolderID(folders.len() - 1);
+            }
+        }
+        
+        Ok(PathStorage {
+            folders,
+            files,
+        })
+    }
+
+    fn get_file(&self, file_id: FileID) -> &CodeFile {
+        &self.files[file_id.0]
+    }
+
+    fn get_file_mut(&mut self, file_id: FileID) -> &mut CodeFile {
+        &mut self.files[file_id.0]
+    }
+
+    fn get_folder(&self, folder_id: FolderID) -> &CodeFolder {
+        &self.folders[folder_id.0]
+    }
+
+    fn get_folder_mut(&mut self, folder_id: FolderID) -> &mut CodeFolder {
+        &mut self.folders[folder_id.0]
+    }
+
+    pub fn reconstruct_file(&self, id: FileID) -> String {
+        let mut sb = self.get_file(id).current.clone();
+        let mut current = self.get_file(id).parent;
+        while current.0 != 0 {
+            sb = self.get_folder(current).current.clone() + "/" + &sb;
+            current = self.get_folder(current).parent;
+        }
+        sb
+    }
+
+    pub fn reconstruct_folder(&self, id: FolderID) -> String {
+        let mut sb = format!("{}", &self.get_folder(id).current);
+        let mut current = self.get_folder(id).parent;
+        while current.0 != 0 {
+            sb = self.get_folder(current).current.clone() + "/" + &sb;
+            current = self.get_folder(current).parent;
+        }
+        sb
+    }
+    
+    pub fn get_file_path_id_checked<'a>(&mut self, path: Span<'a>) -> ParseResult<(), (FileID, bool), ErrorTree<'a>> {
+        let mut path_rem = path;
+        let mut last_dot = false;
+        while let Ok((rem, c)) = anychar::<_, ErrorTree>(path_rem) {
+            if c.is_alphanumeric() || c == '_' || c == '/' {
+                last_dot = false;
+                path_rem = rem;
+                continue;
+            }
+            if c == '.' {
+                if last_dot {
+                    return Err(create_custom_error(
+                        "Double '.'s not allowed in path".to_string(),
+                        path_rem,
+                    ));
+                }
+                path_rem = rem;
+                last_dot = true;
+                continue;
+            }
+            
+            let mut utf8 = [0u8; 4];
+            c.encode_utf8(&mut utf8);
+            let mut utf8_str = "[".to_string();
+            utf8_str += &utf8.map(|b| format!("{b:02X}")).join(", ");
+            utf8_str.push(']');
+
+
+            return Err(create_custom_error(
+                format!("Invalid character in path '{}' - UTF-8 bytes: {}. Allowed characters are alphanumerics, '_' and '/'", c, utf8_str),
+                path_rem,
+            ));
+        }
+
+        let mut current = FolderID(0);
+
+        for (is_last, section) in path.split('/').identify_last() {
+            if is_last {
+                return if let Some(id) = self.get_folder(current).child_files.get(section) {
+                    Ok(((), (*id, false)))
+                } else {
+                    self.files.push(CodeFile { parent: current, current: section.to_string(), use_files: vec![], use_folders: vec![] });
+                    let id = FileID(self.files.len() - 1);
+                    self.get_folder_mut(current).child_files.insert(section.to_string(), id);
+                    Ok(((), (id, true)))
+                };
+            }
+            else {
+                current = if let Some(id) = self.get_folder(current).child_folders.get(section) {
+                    *id
+                } else {
+                    self.folders.push(CodeFolder {
+                        parent: current,
+                        child_folders: Default::default(),
+                        child_files: Default::default(),
+                        current: section.to_string(),
+                    });
+                    let id = FolderID(self.folders.len() - 1);
+                    self.get_folder_mut(current).child_folders.insert(section.to_string(), id);
+                    id
+                };
+            }
+        }
+
+        panic!()
+    }
+}
\ No newline at end of file
diff --git a/src/root/parser/use_parser.rs b/src/root/parser/use_parser.rs
index 0453c9d..5e8b025 100644
--- a/src/root/parser/use_parser.rs
+++ b/src/root/parser/use_parser.rs
@@ -7,8 +7,9 @@ use crate::root::errors::parser_errors::create_custom_error;
 use crate::root::parser::location::Location;
 use crate::root::parser::parse::{ErrorTree, ParseResult, Span};
 use crate::root::parser::parse_util::discard_ignored;
+use crate::root::parser::path_storage::{FileID, PathStorage};
 
-pub fn parse_uses(s: Span) -> ParseResult<Span, Vec<(PathBuf, Location)>> {
+pub fn parse_uses<'a>(s: Span<'a>, path_storage: &mut PathStorage) -> ParseResult<'a, Span<'a>, Vec<(FileID, Location)>> {
     let mut s = s;
     let mut found_paths = Vec::new();
     loop {
@@ -35,28 +36,12 @@ pub fn parse_uses(s: Span) -> ParseResult<Span, Vec<(PathBuf, Location)>> {
             ));
         }
 
-        let mut path_rem = path;
-        while let Ok((rem, c)) = anychar::<_, ErrorTree>(path_rem) {
-            if c.is_alphanumeric() || c == '_' || c == '/' {
-                path_rem = rem;
-                continue;
-            }
-            let mut utf8 = [0u8; 4];
-            c.encode_utf8(&mut utf8);
-            let mut utf8_str = "[".to_string();
-            utf8_str += &utf8.map(|b| format!("{b:02X}")).join(", ");
-            utf8_str.push(']');
-
-
-            return Err(create_custom_error(
-                format!("Invalid character in path '{}' - UTF-8 bytes: {}. Allowed characters are alphanumerics, '_' and '/'", c, utf8_str),
-                path_rem,
-            ));
+        let (_, (id, new)) = path_storage.get_file_path_id_checked(path)?;
+        
+        if new {
+            found_paths.push((id, Location::from_span(&path)));
         }
-
-        let path_buf = PathBuf::from(format!("{}.why", path));
-        found_paths.push((path_buf, Location::from_span(&path)));
-
+        
         s = ns;
     }
 }
diff --git a/src/root/utils/identify_first_last.rs b/src/root/utils/identify_first_last.rs
new file mode 100644
index 0000000..bc3d0c1
--- /dev/null
+++ b/src/root/utils/identify_first_last.rs
@@ -0,0 +1,68 @@
+// ! Modified from https://users.rust-lang.org/t/iterator-need-to-identify-the-last-element/8836/3
+// ! Specifically from users @Nemo157 and @reu
+
+//! This module contains general helper traits.
+use std::{ iter, mem };
+
+pub trait IdentifyFirstLast: Iterator + Sized {
+    fn identify_first_last(self) -> IterFirstLast<Self>;
+}
+
+pub trait IdentifyFirst: Iterator + Sized {
+    fn identify_first(self) -> IterFirst<Self>;
+}
+
+pub trait IdentifyLast: Iterator + Sized {
+    fn identify_last(self) -> IterLast<Self>;
+}
+
+
+impl<I> IdentifyFirstLast for I where I: Iterator {
+    fn identify_first_last(self) -> IterFirstLast<Self> {
+        IterFirstLast(true, self.peekable())
+    }
+}
+
+impl<I> IdentifyFirst for I where I: Iterator {
+    fn identify_first(self) -> IterFirst<Self> {
+        IterFirst(true, self)
+    }
+}
+
+impl<I> IdentifyLast for I where I: Iterator {
+    fn identify_last(self) -> IterLast<Self> {
+        IterLast(true, self.peekable())
+    }
+}
+
+pub struct IterFirstLast<I>(bool, iter::Peekable<I>) where I: Iterator;
+
+pub struct IterFirst<I>(bool, I) where I: Iterator;
+
+pub struct IterLast<I>(bool, iter::Peekable<I>) where I: Iterator;
+
+impl<I> Iterator for IterFirstLast<I> where I: Iterator {
+    type Item = (bool, bool, I::Item);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let first = mem::replace(&mut self.0, false);
+        self.1.next().map(|e| (first, self.1.peek().is_none(), e))
+    }
+}
+
+impl<I> Iterator for IterFirst<I> where I: Iterator  {
+    type Item = (bool, I::Item);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let first = mem::replace(&mut self.0, false);
+        self.1.next().map(|e| (first, e))
+    }
+}
+
+impl<I> Iterator for IterLast<I> where I: Iterator {
+    type Item = (bool, I::Item);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.1.next().map(|e| (self.1.peek().is_none(), e))
+    }
+}
\ No newline at end of file
diff --git a/src/root/utils.rs b/src/root/utils/mod.rs
similarity index 86%
rename from src/root/utils.rs
rename to src/root/utils/mod.rs
index e079951..1ee29d7 100644
--- a/src/root/utils.rs
+++ b/src/root/utils/mod.rs
@@ -1,3 +1,5 @@
+pub mod identify_first_last;
+
 use color_print::cprintln;
 use std::io;
 use std::io::ErrorKind;
@@ -30,19 +32,6 @@ macro_rules! time {
     };
 }
 
-// #[macro_export]
-// macro_rules! try {
-//     ($($tts:tt)*) => {
-//         match $($tts)* {
-//             Err(e) => {
-//                 println!("\n{}");
-//                 return;
-//             }
-//             Ok(v) => v
-//         }
-//     };
-// }
-
 /// Times how long code takes to execute and puts it in `out`
 #[macro_export]
 macro_rules! ret_time {
diff --git a/todo.txt b/todo.txt
index beab3ac..5e193e9 100644
--- a/todo.txt
+++ b/todo.txt
@@ -6,4 +6,7 @@
   - Add [int; 12] / &[int; 12] parsing support into UnresolvedTypeRefToken
   - Add support for parsing array literals
   - Add evaluation support for array literals
+  
+- Check for circular imports
+- Restrict characters usable in path
 - Namespacing