From 0e1d9bdb6224c3eea5342b2022656902d71465a7 Mon Sep 17 00:00:00 2001
From: Robert-M-Lucas <robert-m-lucas@example.com>
Date: Sun, 2 Jun 2024 18:34:30 +0100
Subject: [PATCH] Improved name system

---
 .idea/inspectionProfiles/Project_Default.xml  |  6 +++
 .idea/workspace.xml                           | 43 ++++++++++++++-----
 src/root/name_resolver/name_resolvers.rs      | 26 ++++++-----
 src/root/name_resolver/resolve_names.rs       |  8 ++--
 src/root/parser/parse.rs                      |  3 +-
 src/root/parser/parse_arguments.rs            |  4 +-
 src/root/parser/parse_function.rs             | 14 +++---
 .../parser/parse_function/parse_assignment.rs | 16 +++----
 src/root/parser/parse_function/parse_break.rs |  4 +-
 .../parser/parse_function/parse_evaluable.rs  | 10 ++---
 src/root/parser/parse_function/parse_if.rs    | 14 +++---
 .../parse_function/parse_initialisation.rs    | 16 +++----
 src/root/parser/parse_function/parse_line.rs  | 13 +++---
 .../parser/parse_function/parse_return.rs     | 10 ++---
 src/root/parser/parse_function/parse_while.rs | 12 +++---
 src/root/parser/parse_impl.rs                 | 10 ++++-
 src/root/parser/parse_name.rs                 | 36 ++++++++++++----
 src/root/parser/parse_parameters.rs           |  9 ++--
 src/root/parser/parse_struct.rs               |  2 +-
 19 files changed, 161 insertions(+), 95 deletions(-)
 create mode 100644 .idea/inspectionProfiles/Project_Default.xml

diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 0000000..7d228a9
--- /dev/null
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="t" enabled="true" level="TEXT ATTRIBUTES" enabled_by_default="true" editorAttributes="CONSIDERATION_ATTRIBUTES" />
+  </profile>
+</component>
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 4188ec3..633c762 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -7,7 +7,26 @@
     <cargoProject FILE="$PROJECT_DIR$/Cargo.toml" />
   </component>
   <component name="ChangeListManager">
-    <list default="true" id="6ca282eb-dc8c-4af0-945c-cd77d70c6194" name="Changes" comment="Changes" />
+    <list default="true" id="6ca282eb-dc8c-4af0-945c-cd77d70c6194" name="Changes" comment="Changes">
+      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" 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/name_resolver/resolve_names.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/name_resolver/resolve_names.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/parser/parse_arguments.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_arguments.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_assignment.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_assignment.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_break.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_break.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_evaluable.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_evaluable.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_if.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_if.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_initialisation.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_initialisation.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_line.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_line.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_return.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_return.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_while.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_while.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_impl.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_impl.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_name.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_name.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_parameters.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_parameters.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_struct.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_struct.rs" afterDir="false" />
+    </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
     <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
@@ -23,21 +42,21 @@
   <component name="Git.Settings">
     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
   </component>
-  <component name="GitHubPullRequestSearchHistory"><![CDATA[{
-  "lastFilter": {
-    "state": "OPEN",
-    "assignee": "Robert-M-Lucas"
+  <component name="GitHubPullRequestSearchHistory">{
+  &quot;lastFilter&quot;: {
+    &quot;state&quot;: &quot;OPEN&quot;,
+    &quot;assignee&quot;: &quot;Robert-M-Lucas&quot;
   }
-}]]></component>
+}</component>
   <component name="GitToolBoxStore">
     <option name="projectConfigVersion" value="5" />
   </component>
-  <component name="GithubPullRequestsUISettings"><![CDATA[{
-  "selectedUrlAndAccountId": {
-    "url": "https://github.com/Robert-M-Lucas/whython-8",
-    "accountId": "dcb8df19-0b39-47e1-9073-4a54f7034be8"
+  <component name="GithubPullRequestsUISettings">{
+  &quot;selectedUrlAndAccountId&quot;: {
+    &quot;url&quot;: &quot;https://github.com/Robert-M-Lucas/whython-8.git&quot;,
+    &quot;accountId&quot;: &quot;dcb8df19-0b39-47e1-9073-4a54f7034be8&quot;
   }
-}]]></component>
+}</component>
   <component name="MacroExpansionManager">
     <option name="directoryName" value="u41t3cql" />
   </component>
@@ -121,6 +140,8 @@
       <workItem from="1714088146134" duration="1644000" />
       <workItem from="1714146213417" duration="17000" />
       <workItem from="1714715008037" duration="595000" />
+      <workItem from="1717343732407" duration="809000" />
+      <workItem from="1717345545230" duration="3705000" />
     </task>
     <task id="LOCAL-00001" summary="Changes">
       <option name="closed" value="true" />
diff --git a/src/root/name_resolver/name_resolvers.rs b/src/root/name_resolver/name_resolvers.rs
index 2bd8276..845e549 100644
--- a/src/root/name_resolver/name_resolvers.rs
+++ b/src/root/name_resolver/name_resolvers.rs
@@ -1,23 +1,26 @@
 use std::collections::HashMap;
 use crate::root::name_resolver::resolve::{AddressedTypeRef, FunctionSignature};
 use crate::root::name_resolver::resolve_names::Type;
-use crate::root::parser::parse_name::NameToken;
+use crate::root::parser::parse_name::UnresolvedNameToken;
 
+/// Contents of a `DefinitionTable`
 enum DefinitionTableEntry {
     Table(Box<DefinitionTable>),
     Function(isize),
     Type(isize),
 }
 
+/// Recursive tree containing all named objects/functions/types
 struct DefinitionTable {
     table: HashMap<String, DefinitionTableEntry>
 }
 
-struct VariableTable {
+/// Function-local table of defined variables. Only used within function processing
+struct LocalVariableTable {
     table: HashMap<String, AddressedTypeRef>
 }
 
-impl VariableTable {
+impl LocalVariableTable {
     pub fn new() { todo!(); }
 
     pub fn get_ref(&self, name: &str) -> Option<AddressedTypeRef> {
@@ -44,33 +47,36 @@ impl VariableTable {
     }
 }
 
-struct FullNameTable {
+struct GlobalDefinitionTable {
     builtin_type_definitions: HashMap<isize, Box<dyn Type>>,
     global_type_definitions: HashMap<isize, Box<dyn Type>>,
     global_function_signatures: HashMap<isize, FunctionSignature>,
-    // global_variables
-    global_definition_table: DefinitionTable,
-    local_variable_table: VariableTable
+    definition_table: DefinitionTable
 }
 
+
 enum NameResult<'a> {
     Function(&'a FunctionSignature),
     Type(&'a dyn Type),
     Variable(AddressedTypeRef, &'a dyn Type)
 }
 
-impl FullNameTable {
+impl GlobalDefinitionTable {
     pub fn new() { todo!(); }
 
-    pub fn resolve_name(&self, name: &NameToken) -> NameResult {
+    pub fn resolve_local_name(&self, name: &UnresolvedNameToken, local_variable_table: &LocalVariableTable) -> NameResult {
         let temp_name = &name.names()[0].1;
 
         if let Some((a, t)) =
-            self.local_variable_table.get_ref_and_type(
+            local_variable_table.get_ref_and_type(
                 temp_name, &[&self.global_type_definitions, &self.builtin_type_definitions]
             ) {
             return NameResult::Variable(a, t);
         }
         todo!()
     }
+
+    pub fn resolve_global_name(&self, name: &UnresolvedNameToken) -> NameResult {
+        todo!()
+    }
 }
diff --git a/src/root/name_resolver/resolve_names.rs b/src/root/name_resolver/resolve_names.rs
index 63b7316..6053195 100644
--- a/src/root/name_resolver/resolve_names.rs
+++ b/src/root/name_resolver/resolve_names.rs
@@ -6,7 +6,7 @@ use crate::root::name_resolver::resolve::TypeRef;
 use crate::root::name_resolver::resolve_type_sizes::{resolve_type_sizes, UnsizedUserType};
 use crate::root::parser::parse::Location;
 use crate::root::parser::parse_function::FunctionToken;
-use crate::root::parser::parse_name::NameToken;
+use crate::root::parser::parse_name::UnresolvedNameToken;
 use crate::root::parser::parse_toplevel::TopLevelTokens;
 
 #[derive(Hash)]
@@ -19,8 +19,8 @@ impl TypeName {
         TypeName { name }
     }
 
-    pub fn from_name_token(name: NameToken) -> TypeName {
-        TypeName { name: name.dissolve().1 }
+    pub fn from_name_token(name: UnresolvedNameToken) -> TypeName {
+        TypeName { name: name.dissolve().4 }
     }
 }
 
@@ -34,6 +34,8 @@ impl Eq for TypeName {}
 
 pub trait Type {}
 
+
+/// A whython-code-defined type
 #[derive(Getters)]
 pub struct UserType {
     id: isize,
diff --git a/src/root/parser/parse.rs b/src/root/parser/parse.rs
index 7eeeb59..e00e173 100644
--- a/src/root/parser/parse.rs
+++ b/src/root/parser/parse.rs
@@ -5,6 +5,7 @@ use nom_supreme::error::GenericErrorTree;
 use std::fs;
 use std::path::PathBuf;
 use std::rc::Rc;
+use derive_getters::Getters;
 use crate::root::parser::parse_toplevel::TopLevelTokens;
 
 pub type Span<'a> = LocatedSpan<&'a str, &'a Rc<PathBuf>>;
@@ -17,7 +18,7 @@ pub type ErrorTree<'a> = GenericErrorTree<
     Box<dyn std::error::Error + Send + Sync + 'static>,
 >;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Getters)]
 pub struct Location {
     path: Rc<PathBuf>,
     offset: usize,
diff --git a/src/root/parser/parse_arguments.rs b/src/root/parser/parse_arguments.rs
index eb2549c..50c1a5a 100644
--- a/src/root/parser/parse_arguments.rs
+++ b/src/root/parser/parse_arguments.rs
@@ -3,7 +3,7 @@ use nom::InputTake;
 use crate::root::parser::parse::{ErrorTree, ParseResult, Span};
 use crate::root::parser::parse_function::parse_evaluable::{EvaluableToken, parse_evaluable};
 
-pub fn parse_arguments(s: Span) -> ParseResult<Span, Vec<EvaluableToken>> {
+pub fn parse_arguments<'a, 'b>(s: Span<'a>, containing_class: Option<&'b str>) -> ParseResult<'a, Span<'a>, Vec<EvaluableToken>> {
     let mut s = s;
     let mut args = Vec::new();
     let mut last = false;
@@ -17,7 +17,7 @@ pub fn parse_arguments(s: Span) -> ParseResult<Span, Vec<EvaluableToken>> {
             s.take_split(s.len())
         };
 
-        args.push(parse_evaluable(section, false)?.1);
+        args.push(parse_evaluable(section, containing_class, false)?.1);
 
         s = ns;
         if last {
diff --git a/src/root/parser/parse_function.rs b/src/root/parser/parse_function.rs
index 4b1d05d..0abf60f 100644
--- a/src/root/parser/parse_function.rs
+++ b/src/root/parser/parse_function.rs
@@ -7,7 +7,7 @@ use substring::Substring;
 use crate::root::parser::parse::{ErrorTree, Location, ParseResult, Span};
 use crate::root::parser::parse_blocks::default_section;
 use crate::root::parser::parse_function::parse_line::{parse_lines, LineTokens};
-use crate::root::parser::parse_name::{parse_full_name, parse_simple_name, NameToken};
+use crate::root::parser::parse_name::{parse_full_name, parse_simple_name, UnresolvedNameToken};
 use crate::root::parser::parse_parameters::{parse_parameters, Parameters};
 use crate::root::parser::parse_toplevel::{TopLevelTokens, ToplevelTestFn};
 use crate::root::parser::parse_util::{discard_ignored, require_ignored};
@@ -28,7 +28,7 @@ pub mod parse_while;
 pub struct FunctionToken {
     location: Location,
     name: String,
-    return_type: Option<NameToken>,
+    return_type: Option<UnresolvedNameToken>,
     parameters: Parameters,
     lines: Vec<LineTokens>,
 }
@@ -42,12 +42,16 @@ pub fn test_parse_function<'a>(s: Span<'a>) -> ParseResult<Span, ToplevelTestFn<
     }
 }
 
-pub fn parse_function(s: Span, allow_self: Option<NameToken>) -> ParseResult<Span, FunctionToken> {
+pub fn parse_function(s: Span, allow_self: Option<UnresolvedNameToken>) -> ParseResult<Span, FunctionToken> {
     let location = Location::from_span(&s);
     let (s, _) = tag("fn").parse(s)?;
     let (s, _) = require_ignored(s)?;
     let (s, name) = parse_simple_name(s)?;
     let (s, _) = discard_ignored(s)?;
+    let c_owned = allow_self.as_ref().and_then(|s| Some(s.base().to_string()));
+    let containing_class = if let Some(s) = &c_owned {
+        Some(s.as_str())
+    } else { None };
 
     let (s, contents) = default_section(s, '(')?;
     let (_, parameters) = parse_parameters(contents, allow_self)?;
@@ -56,7 +60,7 @@ pub fn parse_function(s: Span, allow_self: Option<NameToken>) -> ParseResult<Spa
 
     let (s, return_type) = if let Ok((s, _)) = tag::<_, _, ErrorTree>("->")(s) {
         let (s, _) = discard_ignored(s)?;
-        let (s, return_type) = parse_full_name(s)?;
+        let (s, return_type) = parse_full_name(s, containing_class.and_then(|s| Some(s.to_string())))?;
         (discard_ignored(s)?.0, Some(return_type))
     } else {
         (s, None)
@@ -64,7 +68,7 @@ pub fn parse_function(s: Span, allow_self: Option<NameToken>) -> ParseResult<Spa
 
     let (s, contents) = default_section(s, '{')?;
 
-    let (_, lines) = parse_lines(contents)?;
+    let (_, lines) = parse_lines(contents, containing_class)?;
 
     Ok((
         s,
diff --git a/src/root/parser/parse_function/parse_assignment.rs b/src/root/parser/parse_function/parse_assignment.rs
index 60fbf16..ec1ef7c 100644
--- a/src/root/parser/parse_function/parse_assignment.rs
+++ b/src/root/parser/parse_function/parse_assignment.rs
@@ -6,35 +6,35 @@ use crate::root::parser::parse_function::parse_assigner::{AssignmentOperatorToke
 use crate::root::parser::parse_function::parse_evaluable::{EvaluableToken, parse_evaluable};
 use crate::root::parser::parse_function::parse_initialisation::parse_initialisation;
 use crate::root::parser::parse_function::parse_line::{LineTestFn, LineTokens};
-use crate::root::parser::parse_name::{NameToken, parse_full_name};
+use crate::root::parser::parse_name::{UnresolvedNameToken, parse_full_name};
 use crate::root::parser::parse_util::discard_ignored;
 
 #[derive(Debug)]
 pub struct AssignmentToken {
     location: Location,
-    name: NameToken,
+    name: UnresolvedNameToken,
     assignment_operator: AssignmentOperatorToken,
     value: EvaluableToken,
 }
 
 // TODO: Find good way to implement?
-pub fn test_parse_assignment<'a>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a>> {
+pub fn test_parse_assignment<'a, 'b>(s: Span<'a>) -> ParseResult<'a, Span<'a>, LineTestFn<'a, 'b>> {
     let (s, _) = discard_ignored(s)?;
-    let (s, _) = parse_full_name(s)?;
+    let (s, _) = parse_full_name(s, None)?;
     let (s, _) = discard_ignored(s)?;
     let (s, _) = parse_assigner(s)?;
 
-    Ok((s, |x| parse_assignment(x).map(|(s, x)| (s, LineTokens::Assignment(x)))))
+    Ok((s, |x, c| parse_assignment(x, c).map(|(s, x)| (s, LineTokens::Assignment(x)))))
 }
 
-pub fn parse_assignment(s: Span) -> ParseResult<Span, AssignmentToken> {
+pub fn parse_assignment<'a, 'b>(s: Span<'a>, containing_class: Option<&'b str>) -> ParseResult<'a, Span<'a>, AssignmentToken> {
     let (s, _) = discard_ignored(s)?;
     let location = Location::from_span(&s);
-    let (s, n) = parse_full_name(s)?;
+    let (s, n) = parse_full_name(s, containing_class.and_then(|s| Some(s.to_string())))?;
     let (s, _) = discard_ignored(s)?;
     let (s, a) = parse_assigner(s)?;
     let (s, _) = discard_ignored(s)?;
-    let (s, e) = parse_evaluable(s, true)?;
+    let (s, e) = parse_evaluable(s, containing_class, true)?;
     Ok((s, AssignmentToken {
         location,
         name: n,
diff --git a/src/root/parser/parse_function/parse_break.rs b/src/root/parser/parse_function/parse_break.rs
index cc95c4f..be22dd0 100644
--- a/src/root/parser/parse_function/parse_break.rs
+++ b/src/root/parser/parse_function/parse_break.rs
@@ -12,9 +12,9 @@ pub struct BreakToken {
     location: Location,
 }
 
-pub fn test_parse_break<'a>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a>> {
+pub fn test_parse_break<'a, 'b>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a, 'b>> {
     match tag("break")(s) {
-        Ok(_) => Ok((s, |x| {
+        Ok(_) => Ok((s, |x, _| {
             parse_break(x).map(|(s, x)| (s, LineTokens::Break(x)))
         })),
         Err(e) => Err(e),
diff --git a/src/root/parser/parse_function/parse_evaluable.rs b/src/root/parser/parse_function/parse_evaluable.rs
index 7cbb0c3..b59cbfc 100644
--- a/src/root/parser/parse_function/parse_evaluable.rs
+++ b/src/root/parser/parse_function/parse_evaluable.rs
@@ -3,7 +3,7 @@ use crate::root::parser::parse_function::parse_literal::{
     parse_literal, LiteralToken, LiteralTokens,
 };
 use crate::root::parser::parse_function::parse_operator::{parse_operator, OperatorToken};
-use crate::root::parser::parse_name::{parse_full_name, NameToken};
+use crate::root::parser::parse_name::{parse_full_name, UnresolvedNameToken};
 use b_box::b;
 use nom::branch::alt;
 use nom::character::complete::{char};
@@ -25,7 +25,7 @@ pub fn temp_from_token(s: Span, token: EvaluableTokens) -> TempEvaluableTokens {
 
 #[derive(Debug)]
 enum EvaluableTokens {
-    Name(NameToken),
+    Name(UnresolvedNameToken),
     Literal(LiteralToken),
     InfixOperator(Box<EvaluableToken>, OperatorToken, Box<EvaluableToken>),
     PrefixOperator(OperatorToken, Box<EvaluableToken>),
@@ -37,7 +37,7 @@ enum TempEvaluableTokens {
     Operator(OperatorToken),
 }
 
-pub fn parse_evaluable(s: Span, semicolon_terminated: bool) -> ParseResult<Span, EvaluableToken> {
+pub fn parse_evaluable<'a, 'b>(s: Span<'a>, containing_class: Option<&'b str>, semicolon_terminated: bool) -> ParseResult<'a, Span<'a>, EvaluableToken> {
     assert!(!s.is_empty());
     let mut s = s;
 
@@ -66,7 +66,7 @@ pub fn parse_evaluable(s: Span, semicolon_terminated: bool) -> ParseResult<Span,
         }
 
         let ns = if let Ok((ns, _)) = default_section(s, '(') {
-            let (ns, evaluable) = parse_evaluable(ns, false)?;
+            let (ns, evaluable) = parse_evaluable(ns, containing_class.clone(), false)?;
             evaluables.push(TempEvaluableTokens::EvaluableToken(evaluable));
             ns
         } else {
@@ -77,7 +77,7 @@ pub fn parse_evaluable(s: Span, semicolon_terminated: bool) -> ParseResult<Span,
                 },
                 |x| parse_operator(x).map(|(s, t)| (s, TempEvaluableTokens::Operator(t))),
                 |x| {
-                    parse_full_name(x)
+                    parse_full_name(x, containing_class.and_then(|s| Some(s.to_string())))
                         .map(|(s, t)| (s, temp_from_token(s, EvaluableTokens::Name(t))))
                 },
             ))(ns)?;
diff --git a/src/root/parser/parse_function/parse_if.rs b/src/root/parser/parse_function/parse_if.rs
index 2aa7d92..0931087 100644
--- a/src/root/parser/parse_function/parse_if.rs
+++ b/src/root/parser/parse_function/parse_if.rs
@@ -17,21 +17,21 @@ pub struct IfToken {
     else_contents: Option<Vec<LineTokens>>,
 }
 
-pub fn test_parse_if<'a>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a>> {
+pub fn test_parse_if<'a, 'b>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a, 'b>> {
     match tag("if")(s) {
-        Ok(_) => Ok((s, |x| parse_if(x).map(|(s, x)| (s, LineTokens::If(x))))),
+        Ok(_) => Ok((s, |x, c| parse_if(x, c).map(|(s, x)| (s, LineTokens::If(x))))),
         Err(e) => Err(e),
     }
 }
 
-pub fn parse_if(s: Span) -> ParseResult<Span, IfToken> {
+pub fn parse_if<'a, 'b>(s: Span<'a>, containing_class: Option<&'b str>) -> ParseResult<'a, Span<'a>, IfToken> {
     let (s, l) = tag("if")(s)?;
     let (s, _) = discard_ignored(s)?;
     let (s, content) = default_section(s, '(')?;
-    let (_, if_condition) = parse_evaluable(content, false)?;
+    let (_, if_condition) = parse_evaluable(content, containing_class,false)?;
     let (s, _) = discard_ignored(s)?;
     let (s, contents) = default_section(s, '{')?;
-    let (_, if_contents) = parse_lines(contents)?;
+    let (_, if_contents) = parse_lines(contents, containing_class)?;
 
     let mut elifs = Vec::new();
     let mut s = s;
@@ -54,7 +54,7 @@ pub fn parse_if(s: Span) -> ParseResult<Span, IfToken> {
             if let Ok((ns, _)) = (require_ignored, tag("if")).parse(ns) {
                 let (ns, _) = discard_ignored(ns)?;
                 let (ns, content) = default_section(ns, '(')?;
-                let (_, condition) = parse_evaluable(content, false)?;
+                let (_, condition) = parse_evaluable(content, containing_class, false)?;
                 (ns, Some(condition))
             } else {
                 (ns, None)
@@ -63,7 +63,7 @@ pub fn parse_if(s: Span) -> ParseResult<Span, IfToken> {
         let (ns, _) = discard_ignored(ns)?;
 
         let (ns, contents) = default_section(ns, '{')?;
-        let (_, contents) = parse_lines(contents)?;
+        let (_, contents) = parse_lines(contents, containing_class)?;
 
         // ? Handle else if
         if let Some(condition) = condition {
diff --git a/src/root/parser/parse_function/parse_initialisation.rs b/src/root/parser/parse_function/parse_initialisation.rs
index 3b52918..d915b3d 100644
--- a/src/root/parser/parse_function/parse_initialisation.rs
+++ b/src/root/parser/parse_function/parse_initialisation.rs
@@ -2,7 +2,7 @@ use crate::root::parser::parse::{ErrorTree, Location, ParseResult, Span};
 use crate::root::parser::parse_function::parse_break::parse_break;
 use crate::root::parser::parse_function::parse_evaluable::{parse_evaluable, EvaluableToken};
 use crate::root::parser::parse_function::parse_line::{LineTestFn, LineTokens};
-use crate::root::parser::parse_name::{parse_full_name, parse_simple_name, NameToken};
+use crate::root::parser::parse_name::{parse_full_name, parse_simple_name, UnresolvedNameToken};
 use nom::character::complete::{char};
 use nom::sequence::Tuple;
 use nom::Err::Error;
@@ -15,31 +15,31 @@ use crate::root::parser::parse_util::{discard_ignored, require_ignored};
 pub struct InitialisationToken {
     location: Location,
     name: String,
-    type_name: NameToken,
+    type_name: UnresolvedNameToken,
     value: EvaluableToken,
 }
 
-pub fn test_parse_initialisation<'a>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a>> {
+pub fn test_parse_initialisation<'a, 'b>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a, 'b>> {
     match (tag("let"), require_ignored).parse(s) {
-        Ok(_) => Ok((s, |x| {
-            parse_initialisation(x).map(|(s, x)| (s, LineTokens::Initialisation(x)))
+        Ok(_) => Ok((s, |x, c| {
+            parse_initialisation(x, c).map(|(s, x)| (s, LineTokens::Initialisation(x)))
         })),
         Err(e) => Err(e),
     }
 }
 
-pub fn parse_initialisation(s: Span) -> ParseResult<Span, InitialisationToken> {
+pub fn parse_initialisation<'a, 'b>(s: Span<'a>, containing_class: Option<&'b str>) -> ParseResult<'a, Span<'a>, InitialisationToken> {
     let (s, l) = tag("let")(s)?;
     let (s, _) = require_ignored(s)?;
     let (s, name) = parse_simple_name(s)?;
     let (s, _) = discard_ignored(s)?;
     let (s, _) = char(':')(s)?;
     let (s, _) = discard_ignored(s)?;
-    let (s, type_name) = parse_full_name(s)?;
+    let (s, type_name) = parse_full_name(s, containing_class.and_then(|s| Some(s.to_string())))?;
     let (s, _) = discard_ignored(s)?;
     let (s, _) = char('=')(s)?;
     let (s, _) = discard_ignored(s)?;
-    let (s, value) = parse_evaluable(s, true)?;
+    let (s, value) = parse_evaluable(s, containing_class, true)?;
 
     Ok((
         s,
diff --git a/src/root/parser/parse_function/parse_line.rs b/src/root/parser/parse_function/parse_line.rs
index 3d67d6f..62fdc58 100644
--- a/src/root/parser/parse_function/parse_line.rs
+++ b/src/root/parser/parse_function/parse_line.rs
@@ -24,9 +24,10 @@ pub enum LineTokens {
     NoOp(EvaluableToken),
 }
 
-pub type LineTestFn<'a> = fn(Span<'a>) -> ParseResult<Span<'a>, LineTokens>;
+/// fn(line span, Option<class name>)
+pub type LineTestFn<'a, 'b> = fn(Span<'a>, Option<&'b str>) -> ParseResult<'a, Span<'a>, LineTokens>;
 
-pub fn parse_lines(contents: Span) -> ParseResult<(), Vec<LineTokens>> {
+pub fn parse_lines<'a, 'b>(contents: Span<'a>, containing_class: Option<&'b str>) -> ParseResult<'a, (), Vec<LineTokens>> {
     let mut lines = Vec::new();
 
     let mut c = contents;
@@ -36,7 +37,7 @@ pub fn parse_lines(contents: Span) -> ParseResult<(), Vec<LineTokens>> {
             break;
         }
 
-        let (cs, function) = parse_line(cs)?;
+        let (cs, function) = parse_line(cs, containing_class)?;
 
         lines.push(function);
         c = cs;
@@ -45,7 +46,7 @@ pub fn parse_lines(contents: Span) -> ParseResult<(), Vec<LineTokens>> {
     Ok(((), lines))
 }
 
-pub fn parse_line(s: Span) -> ParseResult<Span, LineTokens> {
+pub fn parse_line<'a, 'b>(s: Span<'a>, containing_class: Option<&'b str>) -> ParseResult<'a, Span<'a>, LineTokens> {
     if let Ok((_, parser)) = alt((
         test_parse_break,
         test_parse_return,
@@ -56,9 +57,9 @@ pub fn parse_line(s: Span) -> ParseResult<Span, LineTokens> {
     ))
     .parse(s)
     {
-        parser(s)
+        parser(s, containing_class)
     } else {
         // ? Default case is evaluable
-        parse_evaluable(s, true).map(|(s, e)| (s, LineTokens::NoOp(e)))
+        parse_evaluable(s, containing_class, true).map(|(s, e)| (s, LineTokens::NoOp(e)))
     }
 }
diff --git a/src/root/parser/parse_function/parse_return.rs b/src/root/parser/parse_function/parse_return.rs
index c5cc26b..d2331d0 100644
--- a/src/root/parser/parse_function/parse_return.rs
+++ b/src/root/parser/parse_function/parse_return.rs
@@ -12,19 +12,19 @@ pub struct ReturnToken {
     return_value: EvaluableToken,
 }
 
-pub fn test_parse_return<'a>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a>> {
+pub fn test_parse_return<'a, 'b>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a, 'b>> {
     match (tag("return"), require_ignored).parse(s) {
-        Ok(_) => Ok((s, |x| {
-            parse_return(x).map(|(s, x)| (s, LineTokens::Return(x)))
+        Ok(_) => Ok((s, |x, c| {
+            parse_return(x, c).map(|(s, x)| (s, LineTokens::Return(x)))
         })),
         Err(e) => Err(e),
     }
 }
 
-pub fn parse_return(s: Span) -> ParseResult<Span, ReturnToken> {
+pub fn parse_return<'a, 'b>(s: Span<'a>, containing_class: Option<&'b str>) -> ParseResult<'a, Span<'a>, ReturnToken> {
     let (s, l) = tag("return")(s)?;
     let (s, _) = require_ignored(s)?;
-    let (s, value) = parse_evaluable(s, true)?;
+    let (s, value) = parse_evaluable(s, containing_class, true)?;
     Ok((
         s,
         ReturnToken {
diff --git a/src/root/parser/parse_function/parse_while.rs b/src/root/parser/parse_function/parse_while.rs
index 994f27d..c0cd96c 100644
--- a/src/root/parser/parse_function/parse_while.rs
+++ b/src/root/parser/parse_function/parse_while.rs
@@ -16,24 +16,24 @@ pub struct WhileToken {
     contents: Vec<LineTokens>,
 }
 
-pub fn test_parse_while<'a>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a>> {
+pub fn test_parse_while<'a, 'b>(s: Span<'a>) -> ParseResult<Span, LineTestFn<'a, 'b>> {
     match (tag("while"), require_ignored).parse(s) {
-        Ok(_) => Ok((s, |x| {
-            parse_while(x).map(|(s, x)| (s, LineTokens::While(x)))
+        Ok(_) => Ok((s, |x, c| {
+            parse_while(x, c).map(|(s, x)| (s, LineTokens::While(x)))
         })),
         Err(e) => Err(e),
     }
 }
 
-pub fn parse_while(s: Span) -> ParseResult<Span, WhileToken> {
+pub fn parse_while<'a, 'b>(s: Span<'a>, containing_class: Option<&'b str>) -> ParseResult<'a, Span<'a>, WhileToken> {
     let (s, l) = tag("while")(s)?;
     let (s, _) = discard_ignored(s)?;
     let (s, content) = default_section(s, '(')?;
-    let (_, condition) = parse_evaluable(content, false)?;
+    let (_, condition) = parse_evaluable(content, containing_class, false)?;
     let (s, _) = discard_ignored(s)?;
     let (s, contents) = default_section(s, '{')?;
 
-    let (_, lines) = parse_lines(contents)?;
+    let (_, lines) = parse_lines(contents, containing_class)?;
 
     Ok((
         s,
diff --git a/src/root/parser/parse_impl.rs b/src/root/parser/parse_impl.rs
index bb46214..3800193 100644
--- a/src/root/parser/parse_impl.rs
+++ b/src/root/parser/parse_impl.rs
@@ -6,7 +6,7 @@ use nom_supreme::tag::complete::tag;
 use crate::root::parser::parse::{Location, ParseResult, Span};
 use crate::root::parser::parse_blocks::default_section;
 use crate::root::parser::parse_function::{parse_function, FunctionToken};
-use crate::root::parser::parse_name::{NameToken, parse_simple_name};
+use crate::root::parser::parse_name::{UnresolvedNameToken, parse_simple_name};
 use crate::root::parser::parse_toplevel::{TopLevelTokens, ToplevelTestFn};
 use crate::root::parser::parse_util::{discard_ignored, require_ignored};
 
@@ -43,7 +43,13 @@ pub fn parse_impl(s: Span) -> ParseResult<Span, ImplToken> {
         if cs.is_empty() {
             break;
         }
-        let (cs, function) = parse_function(cs, Some(NameToken::from_simple(&name)))?;
+
+        let (cs, function) = parse_function(
+            cs,
+            // ? Pass class name (type) to function in case needed for self
+            // ? Pass containing class as null as class does not contain itself
+            Some(UnresolvedNameToken::new_unresolved(&name, None))
+        )?;
 
         functions.push(function);
         c = cs;
diff --git a/src/root/parser/parse_name.rs b/src/root/parser/parse_name.rs
index 29b9e75..2b052b9 100644
--- a/src/root/parser/parse_name.rs
+++ b/src/root/parser/parse_name.rs
@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+use std::rc::Rc;
 use crate::root::parser::parse::{ErrorTree, Location, ParseResult, Span};
 use crate::root::parser::parse_function::parse_evaluable::EvaluableToken;
 use derive_getters::{Dissolve, Getters};
@@ -16,17 +18,28 @@ pub enum NameConnectors {
 }
 
 #[derive(Debug, Dissolve, Getters)]
-pub struct NameToken {
+pub struct UnresolvedNameToken {
     location: Location,
+    file_location: Rc<PathBuf>,
+    containing_class: Option<String>,
+    indirection: usize,
     base: String,
     names: Vec<(NameConnectors, String)>,
     function_call: Option<Vec<EvaluableToken>>,
 }
 
-impl NameToken {
-    pub fn from_simple(s: &Span) -> NameToken {
-        NameToken {
-            location: Location::from_span(s),
+impl UnresolvedNameToken {
+    pub fn new_unresolved(
+        s: &Span,
+        containing_class: Option<String>,
+    ) -> UnresolvedNameToken {
+        let location = Location::from_span(s);
+        let file_location = location.path().clone();
+        UnresolvedNameToken {
+            location,
+            file_location,
+            containing_class,
+            indirection: 0,
             base: s.to_string(),
             names: Vec::new(),
             function_call: None
@@ -34,7 +47,7 @@ impl NameToken {
     }
 }
 
-pub fn parse_full_name(s: Span) -> ParseResult<Span, NameToken> {
+pub fn parse_full_name(s: Span, containing_class: Option<String>) -> ParseResult<Span, UnresolvedNameToken> {
     // TODO: Handle indirection
 
     let (s, _) = discard_ignored(s)?;
@@ -47,7 +60,7 @@ pub fn parse_full_name(s: Span) -> ParseResult<Span, NameToken> {
     let mut function_call = None;
 
     if let Ok((ns, contents)) = default_section(s, '(') {
-        function_call = Some(parse_arguments(contents)?.1);
+        function_call = Some(parse_arguments(contents, containing_class.as_ref().and_then(|s| Some(s.as_str())))?.1);
         s = ns;
     }
     else {
@@ -77,7 +90,7 @@ pub fn parse_full_name(s: Span) -> ParseResult<Span, NameToken> {
             names.push((connector, name.to_string()));
 
             if let Ok((ns, contents)) = default_section(ns, '(') {
-                function_call = Some(parse_arguments(contents)?.1);
+                function_call = Some(parse_arguments(contents, containing_class.as_ref().and_then(|s| Some(s.as_str())))?.1);
                 s = ns;
                 break;
             }
@@ -86,10 +99,15 @@ pub fn parse_full_name(s: Span) -> ParseResult<Span, NameToken> {
         }
     }
 
+    let file_location = location.path().clone();
+
     Ok((
         s,
-        NameToken {
+        UnresolvedNameToken {
             location,
+            file_location,
+            containing_class,
+            indirection: 0, // TODO
             base: base_name.to_string(),
             names,
             function_call,
diff --git a/src/root/parser/parse_parameters.rs b/src/root/parser/parse_parameters.rs
index c2556ed..8b8b6fb 100644
--- a/src/root/parser/parse_parameters.rs
+++ b/src/root/parser/parse_parameters.rs
@@ -1,14 +1,15 @@
 use crate::root::parser::parse::{ParseResult, Span};
-use crate::root::parser::parse_name::{parse_full_name, parse_simple_name, NameToken};
+use crate::root::parser::parse_name::{parse_full_name, parse_simple_name, UnresolvedNameToken};
 use nom::character::complete::{char};
 use crate::root::parser::parse_util::discard_ignored;
 
-pub type Parameters = Vec<(String, NameToken)>;
+pub type Parameters = Vec<(String, UnresolvedNameToken)>;
 
-pub fn parse_parameters(s: Span, mut allow_self: Option<NameToken>) -> ParseResult<(), Parameters> {
+pub fn parse_parameters(s: Span, mut allow_self: Option<UnresolvedNameToken>) -> ParseResult<(), Parameters> {
     let (mut s, _) = discard_ignored(s)?;
 
     let mut parameters = Vec::new();
+    let self_name = allow_self.as_ref().and_then(|s| Some(s.base().to_string()));
 
     while !s.is_empty() {
         let (ns, name) = parse_simple_name(s)?;
@@ -20,7 +21,7 @@ pub fn parse_parameters(s: Span, mut allow_self: Option<NameToken>) -> ParseResu
             let (ns, _) = discard_ignored(ns)?;
             let (ns, _) = char(':')(ns)?;
             let (ns, _) = discard_ignored(ns)?;
-            let (ns, type_name_token) = parse_full_name(ns)?;
+            let (ns, type_name_token) = parse_full_name(ns, self_name.clone())?;
             let (ns, _) = discard_ignored(ns)?;
             (ns, type_name_token)
         };
diff --git a/src/root/parser/parse_struct.rs b/src/root/parser/parse_struct.rs
index 2dd5b90..1bbfc55 100644
--- a/src/root/parser/parse_struct.rs
+++ b/src/root/parser/parse_struct.rs
@@ -1,5 +1,5 @@
 use crate::root::parser::parse::{ErrorTree, Location, ParseResult, Span};
-use crate::root::parser::parse_name::{parse_simple_name, NameToken};
+use crate::root::parser::parse_name::{parse_simple_name, UnresolvedNameToken};
 use crate::root::parser::parse_parameters::{parse_parameters, Parameters};
 use crate::root::parser::parse_toplevel::{TopLevelTokens, ToplevelTestFn};
 use derive_getters::{Dissolve, Getters};