Add shadow import failing test.

Flesh out gather and resolve, add todos, refactor a bit.
Add basic name-analysis phase documentation.
2025-05-20 11:11:29 -05:00 · 2025-05-20 11:09:06 -05:00 · 2025-05-20 08:44:26 -05:00 · 2025-05-19 20:22:13 -05:00 · 2025-05-19 13:52:42 -05:00 · 2025-05-19 09:58:43 -05:00
15 changed files with 1467 additions and 510 deletions
--- a/sketching/may_2025/name_one.dm
+++ b/sketching/may_2025/name_one.dm
@ -1,17 +1,5 @@
-ns greeter
-
-fn main(x: String) {
-    let x = 'Hello';
-    let y = 'World';
-    {
-        let test = 'test';
-        let x = 'x';
-        let y = 'y';
-        let z = 'z';
-        let test = 'oops.';
-    };
-}
-
-pub mod test {
+ns greeter;

+fn main(args: Array<String>) {
+    println(args);
 }
--- a/sketching/may_2025/std_core.dm
+++ b/sketching/may_2025/std_core.dm
@ -0,0 +1,7 @@
+ns std::core;
+
+class Array<T> {}
+
+class String {}
+
+platform fn println(msg: Any) -> Void;
--- a/sketching/may_2025/use.dm
+++ b/sketching/may_2025/use.dm
@ -1,3 +1 @@
-use std::core::println;
-use std::core::*;
 use std::core::{print, println};
--- a/src/ast/build.rs
+++ b/src/ast/build.rs
@ -55,7 +55,9 @@ fn build_fqn(file_id: usize, fqn_pair: Pair<Rule>) -> FullyQualifiedName {
 fn build_type_use(file_id: usize, type_use_pair: Pair<Rule>) -> TypeUse {
    let inner_pair = type_use_pair.into_inner().next().unwrap();
    match inner_pair.as_rule() {
-        Rule::Void => TypeUse::Void,
+        Rule::PrimitiveType => {
+            TypeUse::Primitive(build_primitive_type(file_id, inner_pair))
+        },
        Rule::InterfaceOrClassTypeUse => {
            TypeUse::InterfaceOrClass(build_interface_or_class_type_use(file_id, inner_pair))
        }
@ -65,6 +67,35 @@ fn build_type_use(file_id: usize, type_use_pair: Pair<Rule>) -> TypeUse {
    }
 }

+fn build_primitive_type(
+    file_id: usize,
+    primitive_type_pair: Pair<Rule>,
+) -> PrimitiveTypeUse {
+    let mut inner = primitive_type_pair.into_inner();
+    match inner.next().unwrap().as_rule() {
+        Rule::Byte => PrimitiveTypeUse::Byte,
+        Rule::Short => PrimitiveTypeUse::Short,
+        Rule::Char => PrimitiveTypeUse::Char,
+        Rule::Int => PrimitiveTypeUse::Int,
+        Rule::Long => PrimitiveTypeUse::Long,
+        Rule::Double => PrimitiveTypeUse::Double,
+        Rule::Bool => PrimitiveTypeUse::Bool,
+        Rule::String => PrimitiveTypeUse::String,
+        Rule::Array => {
+            if let Some(generic_arguments_pair) = inner.next() {
+                PrimitiveTypeUse::Array(
+                    Some(Box::new(build_generic_arguments(file_id, generic_arguments_pair)))
+                )
+            } else {
+                PrimitiveTypeUse::Array(None)
+            }
+        }
+        Rule::Any => PrimitiveTypeUse::Any,
+        Rule::Void => PrimitiveTypeUse::Void,
+        _ => unreachable!(),
+    }
+}
+
 fn build_interface_or_class_type_use(file_id: usize, pair: Pair<Rule>) -> InterfaceOrClassTypeUse {
    let mut borrow_count = 0;
    let mut is_mutable = false;
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@ -10,7 +10,8 @@ pub mod build;
 pub mod named;
 pub mod pretty_print;
 pub mod unparse;
-// Operators
+
+/* Operators */

 #[derive(Debug)]
 pub enum Operator {
@ -56,13 +57,13 @@ pub enum SuffixUnaryOperator {

 /* Names */

-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Identifier {
-    pub name: String,
-    pub file_id: usize,
-    pub range: Range<usize>,
+    name: String,
+    file_id: usize,
+    range: Range<usize>,
    scope_id: Option<usize>,
-    symbol: Option<Symbol>,
+    saved_symbol: Option<Symbol>,
 }

 impl Identifier {
@ -72,38 +73,18 @@ impl Identifier {
            file_id,
            range,
            scope_id: None,
-            symbol: None,
+            saved_symbol: None,
        }
    }
-
-    pub fn set_scope_id(&mut self, id: usize) {
-        self.scope_id = Some(id);
-    }
-
-    pub fn scope_id(&self) -> Option<usize> {
-        self.scope_id
-    }
-
-    pub fn set_symbol(&mut self, symbol: Symbol) {
-        self.symbol = Some(symbol);
-    }
-
-    pub fn symbol(&self) -> &Option<Symbol> {
-        &self.symbol
-    }
-
-    pub fn symbol_mut(&mut self) -> Option<Symbol> {
-        self.symbol.clone()
-    }
 }

 #[derive(Debug)]
 pub struct FullyQualifiedName {
-    pub identifiers: Vec<Identifier>,
-    pub file_id: usize,
-    pub range: Range<usize>,
+    identifiers: Vec<Identifier>,
+    file_id: usize,
+    range: Range<usize>,
    scope_id: Option<usize>,
-    symbol: Option<Symbol>,
+    saved_symbol: Option<Symbol>,
 }

 impl FullyQualifiedName {
@ -113,24 +94,25 @@ impl FullyQualifiedName {
            range,
            file_id,
            scope_id: None,
-            symbol: None,
+            saved_symbol: None,
        }
    }

-    pub fn set_scope_id(&mut self, scope_id: usize) {
-        self.scope_id = Some(scope_id);
+    pub fn last(&self) -> &Identifier {
+        &self.identifiers[self.identifiers.len() - 1]
    }

-    pub fn scope_id(&self) -> Option<usize> {
-        self.scope_id
+    pub fn last_mut(&mut self) -> &mut Identifier {
+        let last_index = self.identifiers.len() - 1;
+        &mut self.identifiers[last_index]
    }
    
-    pub fn set_symbol(&mut self, symbol: Symbol) {
-        self.symbol = Some(symbol);
+    pub fn len(&self) -> usize {
+        self.identifiers.len()
    }
    
-    pub fn symbol(&self) -> &Option<Symbol> {
-        &self.symbol
+    pub fn is_single_identifier(&self) -> bool {
+        self.identifiers.len() == 1
    }
 }

@ -138,12 +120,27 @@ impl FullyQualifiedName {

 #[derive(Debug)]
 pub enum TypeUse {
-    Void,
+    Primitive(PrimitiveTypeUse),
    InterfaceOrClass(InterfaceOrClassTypeUse),
    Tuple(TupleTypeUse),
    Function(FunctionTypeUse),
 }

+#[derive(Debug)]
+pub enum PrimitiveTypeUse {
+    Byte,
+    Short,
+    Char,
+    Int,
+    Long,
+    Double,
+    Bool,
+    String,
+    Array(Option<Box<GenericArguments>>),
+    Any,
+    Void,
+}
+
 #[derive(Debug)]
 pub struct InterfaceOrClassTypeUse {
    pub borrow_count: usize,
@ -168,7 +165,7 @@ pub struct FunctionTypeUse {
    pub return_type: ReturnType,
 }

-// Generic arguments
+/* Generic arguments */

 #[derive(Debug)]
 pub struct GenericArguments(pub Vec<TypeUse>);
@ -268,7 +265,7 @@ pub struct ReturnType {
 impl ReturnType {
    pub fn void() -> Self {
        ReturnType {
-            declared_type: Box::new(TypeUse::Void),
+            declared_type: Box::new(TypeUse::Primitive(PrimitiveTypeUse::Void)),
            references: References::default(),
        }
    }
@ -302,7 +299,68 @@ pub struct CompilationUnit {
    pub declarations: Vec<ModuleLevelDeclaration>,
 }

-// Declarations allowed in each level
+/* Use Statement */
+
+#[derive(Debug)]
+pub struct UseStatement {
+    pub identifiers: Vec<Identifier>,
+    pub last: UseStatementLast,
+    pub file_id: usize,
+    pub range: Range<usize>,
+}
+
+impl UseStatement {
+    pub fn new(
+        identifiers: Vec<Identifier>,
+        last: UseStatementLast,
+        file_id: usize,
+        range: Range<usize>,
+    ) -> Self {
+        UseStatement {
+            identifiers,
+            last,
+            file_id,
+            range,
+        }
+    }
+
+    pub fn base_name(&self) -> Cow<'_, str> {
+        use UseStatementLast::*;
+        if self.identifiers.is_empty() {
+            match &self.last {
+                Identifier(_) => Cow::from(""),
+                Star | Identifiers(_) => panic!(), // should never get here because of grammar
+            }
+        } else if self.identifiers.len() == 1 {
+            self.identifiers[0].name()
+        } else {
+            let mut acc = String::new();
+            for (i, identifier) in self.identifiers.iter().enumerate() {
+                acc.push_str(&identifier.name());
+                if i != self.identifiers.len() - 1 {
+                    acc.push_str("::");
+                }
+            }
+            Cow::from(acc)
+        }
+    }
+
+    pub fn is_star(&self) -> bool {
+        match &self.last {
+            UseStatementLast::Star => true,
+            _ => false,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum UseStatementLast {
+    Identifier(Rc<RefCell<Identifier>>),
+    Identifiers(Vec<Rc<RefCell<Identifier>>>),
+    Star,
+}
+
+/* Declarations allowed in each level */

 #[derive(Debug)]
 pub enum ModuleLevelDeclaration {
@ -334,7 +392,7 @@ pub enum ClassLevelDeclaration {
    Field(FieldDeclaration),
 }

-// Declarations
+/* Main Declarations */

 #[derive(Debug)]
 pub struct ModuleDeclaration {
@ -362,7 +420,7 @@ pub struct ClassDeclaration {
    pub declarations: Vec<ClassLevelDeclaration>,
 }

-// Function declarations and components
+/* Function declarations and components */

 #[derive(Debug)]
 pub struct FunctionDefinition {
@ -432,7 +490,7 @@ pub enum FunctionBody {
    Alias(Identifier),
 }

-// Class components
+/* Class components */

 #[derive(Debug)]
 pub struct ClassConstructor(pub Vec<ClassConstructorParameter>);
@ -457,92 +515,7 @@ pub struct FieldDeclaration {
    pub declared_type: TypeUse,
 }

-// Statements
-
-#[derive(Debug)]
-pub struct UseStatement {
-    pub identifiers: Vec<Identifier>,
-    pub last: UseStatementLast,
-    pub file_id: usize,
-    pub range: Range<usize>,
-    scope_id: Option<usize>,
-    symbol: Option<Symbol>,
-}
-
-pub struct UseStatementImport<'a> {
-    pub declared_name: String,
-    pub fqn: String,
-    pub identifier: &'a mut Identifier,
-}
-
-impl UseStatement {
-    pub fn new(
-        identifiers: Vec<Identifier>,
-        last: UseStatementLast,
-        file_id: usize,
-        range: Range<usize>,
-    ) -> Self {
-        UseStatement {
-            identifiers,
-            last,
-            file_id,
-            range,
-            scope_id: None,
-            symbol: None,
-        }
-    }
-
-    pub fn base_name(&self) -> Cow<'_, str> {
-        use UseStatementLast::*;
-        if self.identifiers.is_empty() {
-            match &self.last {
-                Identifier(_) => Cow::from(""),
-                Star | Identifiers(_) => panic!(), // should never get here because of grammar
-            }
-        } else if self.identifiers.len() == 1 {
-            self.identifiers[0].name()
-        } else {
-            let mut acc = String::new();
-            for (i, identifier) in self.identifiers.iter().enumerate() {
-                acc.push_str(&identifier.name());
-                if i != self.identifiers.len() - 1 {
-                    acc.push_str("::");
-                }
-            }
-            Cow::from(acc)
-        }
-    }
-
-    pub fn is_star(&self) -> bool {
-        match &self.last {
-            UseStatementLast::Star => true,
-            _ => false,
-        }
-    }
-
-    pub fn set_scope_id(&mut self, scope_id: usize) {
-        self.scope_id = Some(scope_id);
-    }
-
-    pub fn scope_id(&self) -> Option<usize> {
-        self.scope_id
-    }
-
-    pub fn set_symbol(&mut self, symbol: Symbol) {
-        self.symbol = Some(symbol);
-    }
-
-    pub fn symbol(&self) -> &Option<Symbol> {
-        &self.symbol
-    }
-}
-
-#[derive(Debug)]
-pub enum UseStatementLast {
-    Identifier(Rc<RefCell<Identifier>>),
-    Identifiers(Vec<Rc<RefCell<Identifier>>>),
-    Star,
-}
+/* Statements */

 #[derive(Debug)]
 pub struct BlockStatement {
@ -615,7 +588,7 @@ pub struct ForStatement {
    pub body: BlockStatement,
 }

-// Expressions
+/* Expressions */

 #[derive(Debug)]
 pub enum Expression {
--- a/src/ast/named.rs
+++ b/src/ast/named.rs
@ -1,14 +1,49 @@
 use crate::ast::{FullyQualifiedName, Identifier};
+use crate::name_analysis::symbol::Symbol;
 use std::borrow::Cow;
+use std::range::Range;

 pub trait Named {
    fn name(&self) -> Cow<'_, str>;
+    
+    fn file_id(&self) -> usize;
+    fn range(&self) -> Range<usize>;
+
+    fn set_scope_id(&mut self, scope_id: usize);
+    fn scope_id(&self) -> Option<usize>;
+
+    fn set_saved_symbol(&mut self, symbol: Symbol);
+    fn saved_symbol(&self) -> Option<Symbol>;
 }

 impl Named for Identifier {
    fn name(&self) -> Cow<'_, str> {
        Cow::Borrowed(&self.name)
    }
+    
+    fn file_id(&self) -> usize {
+        self.file_id
+    }
+    
+    fn range(&self) -> Range<usize> {
+        self.range
+    }
+
+    fn set_scope_id(&mut self, id: usize) {
+        self.scope_id = Some(id);
+    }
+
+    fn scope_id(&self) -> Option<usize> {
+        self.scope_id
+    }
+
+    fn set_saved_symbol(&mut self, saved_symbol: Symbol) {
+        self.saved_symbol = Some(saved_symbol);
+    }
+
+    fn saved_symbol(&self) -> Option<Symbol> {
+        self.saved_symbol.clone()
+    }
 }

 impl Named for FullyQualifiedName {
@ -26,4 +61,28 @@ impl Named for FullyQualifiedName {
            Cow::Owned(acc)
        }
    }
+    
+    fn file_id(&self) -> usize {
+        self.file_id
+    }
+    
+    fn range(&self) -> Range<usize> {
+        self.range
+    }
+
+    fn set_scope_id(&mut self, id: usize) {
+        self.scope_id = Some(id);
+    }
+
+    fn scope_id(&self) -> Option<usize> {
+        self.scope_id
+    }
+
+    fn set_saved_symbol(&mut self, symbol: Symbol) {
+        self.saved_symbol = Some(symbol);
+    }
+
+    fn saved_symbol(&self) -> Option<Symbol> {
+        self.saved_symbol.clone()
+    }
 }
--- a/src/bin/dmc/name_analysis.rs
+++ b/src/bin/dmc/name_analysis.rs
@ -7,6 +7,7 @@ use deimos::name_analysis::symbol_table::SymbolTable;
 use deimos::parser::{DeimosParser, Rule};
 use pest::Parser;
 use std::path::PathBuf;
+use deimos::std_core::add_std_core_symbols;

 pub fn name_analysis(paths: &Vec<PathBuf>) -> Result<(), Box<dyn std::error::Error>> {
    let mut compilation_units = vec![];
@ -29,6 +30,7 @@ pub fn name_analysis(paths: &Vec<PathBuf>) -> Result<(), Box<dyn std::error::Err
    }

    let mut symbol_table = SymbolTable::new();
+    add_std_core_symbols(&mut symbol_table).expect("Failed to add std::core symbols.");
    
    let diagnostics = analyze_names(&mut compilation_units, &mut symbol_table);
    if diagnostics.is_empty() {
--- a/src/lib.rs
+++ b/src/lib.rs
@ -6,6 +6,6 @@ pub mod module;
 pub mod name_analysis;
 pub mod object_file;
 pub mod parser;
-mod std_core;
+pub mod std_core;
 pub mod util;
 pub mod vm;
--- a/src/name_analysis/gather.rs
+++ b/src/name_analysis/gather.rs
@ -6,6 +6,7 @@ use crate::name_analysis::symbol::*;
 use crate::name_analysis::symbol_table::{SymbolInsertError, SymbolTable};
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use std::cell::RefCell;
+use std::ops::DerefMut;
 use std::range::Range;
 use std::rc::Rc;

@ -41,13 +42,21 @@ fn handle_insert_error(
    }
 }

+/* Names */
+
+fn gather_identifier(identifier: &mut Identifier, symbol_table: &mut SymbolTable) {
+    identifier.set_scope_id(symbol_table.current_scope_id());
+}
+
 fn gather_fully_qualified_name(
    fully_qualified_name: &mut FullyQualifiedName,
    symbol_table: &mut SymbolTable,
 ) {
-    fully_qualified_name.set_scope_id(symbol_table.current_scope_id());
+    gather_identifier(fully_qualified_name.last_mut(), symbol_table);
 }

+/* Type Use */
+
 fn gather_type_use(
    type_use: &mut TypeUse,
    symbol_table: &mut SymbolTable,
@ -55,7 +64,9 @@ fn gather_type_use(
    diagnostics: &mut Vec<DmDiagnostic>,
 ) {
    match type_use {
-        TypeUse::Void => {}
+        TypeUse::Primitive(primitive_type_use) => {
+            gather_primitive_type_use(primitive_type_use, symbol_table, fqn_context, diagnostics)
+        }
        TypeUse::InterfaceOrClass(interface_or_class_type_use) => {
            gather_interface_or_class_type_use(
                interface_or_class_type_use,
@ -73,6 +84,22 @@ fn gather_type_use(
    }
 }

+fn gather_primitive_type_use(
+    primitive_type_use: &mut PrimitiveTypeUse,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    match primitive_type_use {
+        PrimitiveTypeUse::Array(generic_arguments_opt) => {
+            if let Some(generic_arguments) = generic_arguments_opt {
+                gather_generic_arguments(generic_arguments, symbol_table, fqn_context, diagnostics);
+            }
+        }
+        _ => {}
+    }
+}
+
 fn gather_interface_or_class_type_use(
    interface_or_class_type_use: &mut InterfaceOrClassTypeUse,
    symbol_table: &mut SymbolTable,
@ -105,9 +132,28 @@ fn gather_function_type_use(
    fqn_context: &mut FqnContext,
    diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    todo!()
+    gather_generic_parameters(
+        &mut function_type_use.generics,
+        symbol_table,
+        fqn_context,
+        diagnostics,
+    );
+    gather_parameters(
+        &mut function_type_use.parameters,
+        symbol_table,
+        fqn_context,
+        diagnostics,
+    );
+    gather_return_type(
+        &mut function_type_use.return_type,
+        symbol_table,
+        fqn_context,
+        diagnostics,
+    );
 }

+/* Generic Arguments */
+
 fn gather_generic_arguments(
    generic_arguments: &mut GenericArguments,
    symbol_table: &mut SymbolTable,
@ -119,6 +165,123 @@ fn gather_generic_arguments(
    }
 }

+/* Generic Parameters */
+
+fn gather_generic_parameters(
+    generic_parameters: &mut GenericParameters,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!("Add each Identifier as a type to the current scope; make sure caller's push/pop before/after")
+}
+
+/* Implements List */
+
+fn gather_implements_list(
+    implements_list: &mut ImplementsList,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    for type_use in &mut implements_list.0 {
+        gather_type_use(type_use, symbol_table, fqn_context, diagnostics);
+    }
+}
+
+/* Function Parameters */
+
+fn gather_parameters(
+    parameters: &mut Parameters,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) -> Option<Vec<Rc<ParameterSymbol>>> {
+    parameters
+        .0
+        .iter_mut()
+        .map(|parameter| gather_parameter(parameter, symbol_table, fqn_context, diagnostics))
+        .collect()
+}
+
+fn gather_parameter(
+    parameter: &mut Parameter,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) -> Option<Rc<ParameterSymbol>> {
+    let parameter_name = parameter.identifier.name();
+
+    let insert_result = symbol_table.insert_parameter_symbol(ParameterSymbol::new(
+        &parameter_name,
+        Some(&parameter.identifier),
+    ));
+
+    match insert_result {
+        Ok(parameter_symbol) => {
+            parameter
+                .identifier
+                .set_scope_id(symbol_table.current_scope_id());
+
+            gather_type_use(
+                &mut parameter.type_use,
+                symbol_table,
+                fqn_context,
+                diagnostics,
+            );
+            Some(parameter_symbol)
+        }
+        Err(err) => {
+            handle_insert_error(
+                err,
+                &parameter_name,
+                parameter.identifier.file_id(),
+                parameter.identifier.range(),
+                "function/variable",
+                diagnostics,
+            );
+            None
+        }
+    }
+}
+
+/* Return Type */
+
+fn gather_return_type(
+    return_type: &mut ReturnType,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    gather_type_use(
+        &mut return_type.declared_type,
+        symbol_table,
+        fqn_context,
+        diagnostics,
+    );
+    gather_references(
+        &mut return_type.references,
+        symbol_table,
+        fqn_context,
+        diagnostics,
+    );
+}
+
+/* References */
+
+fn gather_references(
+    references: &mut References,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    for identifier in &mut references.0 {
+        gather_identifier(identifier, symbol_table);
+    }
+}
+
+/* Compilation Unit/Top-level construct */
+
 pub(super) fn gather_compilation_unit(
    compilation_unit: &mut CompilationUnit,
    symbol_table: &mut SymbolTable,
@ -140,6 +303,8 @@ pub(super) fn gather_compilation_unit(
    assert_eq!(symbol_table.current_scope_id(), 0);
 }

+/* Use Statement */
+
 fn handle_use_statement_import(
    symbol_table: &mut SymbolTable,
    base_name: &str,
@ -153,28 +318,29 @@ fn handle_use_statement_import(
        &declared_name,
        Some(identifier.clone()),
    ));
-    if let Err(err) = insert_result {
-        handle_insert_error(
-            err,
-            &declared_name,
-            borrowed_identifier.file_id,
-            borrowed_identifier.range,
-            "Use statement",
-            diagnostics,
-        );
+
+    match insert_result {
+        Ok(use_statement_symbol) => {
+            drop(borrowed_identifier);
+
+            let mut mutable_borrowed_identifier = identifier.borrow_mut();
+
+            gather_identifier(mutable_borrowed_identifier.deref_mut(), symbol_table);
+
+            mutable_borrowed_identifier
+                .set_saved_symbol(Symbol::UseStatement(use_statement_symbol));
+        }
+        Err(err) => {
+            handle_insert_error(
+                err,
+                &declared_name,
+                borrowed_identifier.file_id(),
+                borrowed_identifier.range(),
+                "Use statement",
+                diagnostics,
+            );
+        }
    }
-    drop(borrowed_identifier);
-    let mut mutable_borrowed_identifier = identifier.borrow_mut();
-    mutable_borrowed_identifier.set_scope_id(symbol_table.current_scope_id());
-
-    let use_statement_symbol = symbol_table
-        .lookup(
-            &declared_name,
-            mutable_borrowed_identifier.scope_id().unwrap(),
-        )
-        .unwrap();
-
-    mutable_borrowed_identifier.set_symbol(use_statement_symbol);
 }

 fn gather_use_statement(
@ -205,6 +371,8 @@ fn gather_use_statement(
    }
 }

+/* Declarations allowed in each level */
+
 fn gather_module_level_declaration(
    declaration: &mut ModuleLevelDeclaration,
    symbol_table: &mut SymbolTable,
@ -234,6 +402,26 @@ fn gather_module_level_declaration(
    }
 }

+fn gather_interface_level_declaration(
+    declaration: &mut InterfaceLevelDeclaration,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn gather_class_level_declaration(
+    declaration: &mut ClassLevelDeclaration,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+/* Main Declarations */
+
 fn gather_module_declaration(
    declaration: &mut ModuleDeclaration,
    symbol_table: &mut SymbolTable,
@ -259,8 +447,8 @@ fn gather_module_declaration(
        handle_insert_error(
            err,
            &module_name,
-            declaration.identifier.file_id,
-            declaration.identifier.range,
+            declaration.identifier.file_id(),
+            declaration.identifier.range(),
            "module/type",
            diagnostics,
        )
@ -294,8 +482,8 @@ fn gather_class_declaration(
        handle_insert_error(
            err,
            &declared_name,
-            class_declaration.identifier.file_id,
-            class_declaration.identifier.range,
+            class_declaration.identifier.file_id(),
+            class_declaration.identifier.range(),
            "interface/class",
            diagnostics,
        );
@ -304,6 +492,8 @@ fn gather_class_declaration(
    // todo: scopes, generics, etc.
 }

+/* Function declarations and components */
+
 fn gather_function_definition(
    function: &mut FunctionDefinition,
    symbol_table: &mut SymbolTable,
@ -321,30 +511,64 @@ fn gather_function_definition(
        Some(&function.identifier),
    ));

-    if let Err(err) = insert_result {
-        handle_insert_error(
-            err,
-            &declared_name,
-            function.identifier.file_id,
-            function.identifier.range,
-            "function/variable",
-            diagnostics,
-        )
+    match insert_result {
+        Ok(function_symbol) => {
+            function
+                .identifier
+                .set_scope_id(symbol_table.current_scope_id());
+
+            symbol_table.push_scope(&format!("FunctionParameterScope({})", resolved_name));
+
+            let parameters_result = gather_parameters(
+                &mut function.parameters,
+                symbol_table,
+                fqn_context,
+                diagnostics,
+            );
+
+            match parameters_result {
+                Some(parameter_symbols) => {
+                    function_symbol
+                        .borrow_mut()
+                        .set_parameters(parameter_symbols);
+                }
+                None => {}
+            }
+
+            gather_return_type(
+                &mut function.return_type,
+                symbol_table,
+                fqn_context,
+                diagnostics,
+            );
+
+            symbol_table.push_scope(&format!("FunctionBodyScope({})", resolved_name));
+
+            gather_function_body(&mut function.body, symbol_table, fqn_context, diagnostics);
+
+            symbol_table.pop_scope(); // body
+            symbol_table.pop_scope(); // parameters
+        }
+        Err(err) => {
+            handle_insert_error(
+                err,
+                &declared_name,
+                function.identifier.file_id(),
+                function.identifier.range(),
+                "function/variable",
+                diagnostics,
+            );
+        }
    }
+}

-    function
-        .identifier
-        .set_scope_id(symbol_table.current_scope_id());
-
-    symbol_table.push_scope(&format!("FunctionScope({})", resolved_name));
-    gather_parameters(
-        &mut function.parameters,
-        symbol_table,
-        fqn_context,
-        diagnostics,
-    );
-    gather_function_body(&mut function.body, symbol_table, fqn_context, diagnostics);
-    symbol_table.pop_scope();
+fn gather_operator_function_definition(
+    operator_function_definition: &mut OperatorFunctionDefinition,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
 }

 fn gather_platform_function_definition(
@ -364,78 +588,74 @@ fn gather_platform_function_definition(
        Some(&platform_function_declaration.identifier),
    ));

-    if let Err(err) = insert_result {
-        handle_insert_error(
-            err,
-            &declared_name,
-            platform_function_declaration.identifier.file_id,
-            platform_function_declaration.identifier.range,
-            "(Platform-) Function",
-            diagnostics,
-        );
+    match insert_result {
+        Ok(function_symbol) => {
+            let declared_name_as_string =
+                platform_function_declaration.identifier.name().to_string();
+
+            platform_function_declaration
+                .identifier
+                .set_scope_id(symbol_table.current_scope_id());
+
+            symbol_table.push_scope(&format!(
+                "FunctionParameterScope({})",
+                declared_name_as_string
+            ));
+
+            let parameter_symbols_result = gather_parameters(
+                &mut platform_function_declaration.parameters,
+                symbol_table,
+                fqn_context,
+                diagnostics,
+            );
+
+            match parameter_symbols_result {
+                Some(parameter_symbols) => {
+                    function_symbol
+                        .borrow_mut()
+                        .set_parameters(parameter_symbols);
+                }
+                None => {}
+            }
+
+            gather_return_type(
+                &mut platform_function_declaration.return_type,
+                symbol_table,
+                fqn_context,
+                diagnostics,
+            );
+
+            symbol_table.pop_scope();
+        }
+        Err(err) => {
+            handle_insert_error(
+                err,
+                &declared_name,
+                platform_function_declaration.identifier.file_id(),
+                platform_function_declaration.identifier.range(),
+                "(Platform-) Function",
+                diagnostics,
+            );
+        }
    }
-
-    let declared_name_as_string = platform_function_declaration.identifier.name().to_string();
-
-    platform_function_declaration
-        .identifier
-        .set_scope_id(symbol_table.current_scope_id());
-
-    symbol_table.push_scope(&format!("FunctionScope({})", declared_name_as_string));
-    gather_parameters(
-        &mut platform_function_declaration.parameters,
-        symbol_table,
-        fqn_context,
-        diagnostics,
-    );
-    symbol_table.pop_scope();
 }

-fn gather_parameters(
-    parameters: &mut Parameters,
+fn gather_interface_function_declaration(
+    declaration: &mut InterfaceFunctionDeclaration,
    symbol_table: &mut SymbolTable,
    fqn_context: &mut FqnContext,
    diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for parameter in &mut parameters.0 {
-        gather_parameter(parameter, symbol_table, fqn_context, diagnostics);
-    }
+    todo!()
 }

-fn gather_parameter(
-    parameter: &mut Parameter,
+fn gather_interface_operator_function_declaration(
+    declaration: &mut InterfaceOperatorFunctionDeclaration,
    symbol_table: &mut SymbolTable,
    fqn_context: &mut FqnContext,
    diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let parameter_name = parameter.identifier.name();
-
-    let insert_result = symbol_table.insert_parameter_symbol(ParameterSymbol::new(
-        &parameter_name,
-        Some(&parameter.identifier),
-    ));
-
-    if let Err(err) = insert_result {
-        handle_insert_error(
-            err,
-            &parameter_name,
-            parameter.identifier.file_id,
-            parameter.identifier.range,
-            "function/variable",
-            diagnostics,
-        )
-    }
-
-    parameter
-        .identifier
-        .set_scope_id(symbol_table.current_scope_id());
-
-    gather_type_use(
-        &mut parameter.type_use,
-        symbol_table,
-        fqn_context,
-        diagnostics,
-    )
+    todo!()
 }

 fn gather_function_body(
@ -451,6 +671,37 @@ fn gather_function_body(
    }
 }

+/* Class Components */
+
+fn gather_class_constructor(
+    class_constructor: &mut ClassConstructor,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn gather_property_declaration(
+    property_declaration: &mut PropertyDeclaration,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn gather_field_declaration(
+    field_declaration: &mut FieldDeclaration,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+/* Statements */
+
 fn gather_block_statement(
    block: &mut BlockStatement,
    symbol_table: &mut SymbolTable,
@ -517,8 +768,8 @@ fn gather_variable_declaration(
        handle_insert_error(
            err,
            &variable_name,
-            variable_declaration.identifier.file_id,
-            variable_declaration.identifier.range,
+            variable_declaration.identifier.file_id(),
+            variable_declaration.identifier.range(),
            "function/variable",
            diagnostics,
        )
@ -551,6 +802,55 @@ fn gather_call_statement(
    gather_expression(&mut call_statement.0, symbol_table, diagnostics);
 }

+fn gather_return_statement(
+    return_statement: &mut ReturnStatement,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    if let Some(expression) = &mut return_statement.0 {
+        gather_expression(expression, symbol_table, diagnostics);
+    }
+}
+
+fn gather_if_statement(
+    if_statement: &mut IfStatement,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn gather_if_else_statement(
+    if_else_statement: &mut IfElseStatement,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn gather_while_statement(
+    while_statement: &mut WhileStatement,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn gather_for_statement(
+    for_statement: &mut ForStatement,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+/* Expressions */
+
 fn gather_expression(
    expression: &mut Expression,
    symbol_table: &mut SymbolTable,
@ -673,7 +973,8 @@ fn gather_object_access(
                gather_expression(index_expression, symbol_table, diagnostics);
            }
            ObjectNavigation::Identifier(identifier) => {
-                identifier.set_scope_id(symbol_table.current_scope_id());
+                // TODO: use a special gather for names belonging to a struct
+                gather_identifier(identifier, symbol_table);
            }
        }
    }
@ -685,8 +986,18 @@ fn gather_literal(
    diagnostics: &mut Vec<DmDiagnostic>,
 ) {
    match literal {
-        Literal::DString(d_string) => todo!(),
-        Literal::BacktickString(backtick_string) => todo!(),
+        Literal::DString(d_string) => gather_d_string(d_string, symbol_table, diagnostics),
+        Literal::BacktickString(backtick_string) => {
+            gather_d_string(backtick_string, symbol_table, diagnostics)
+        }
        _ => {}
    }
 }
+
+fn gather_d_string(
+    d_string: &mut DString,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
--- a/src/name_analysis/mod.rs
+++ b/src/name_analysis/mod.rs
@ -1,3 +1,24 @@
+/*!
+# Name Analysis
+
+There are two phases in name analysis.
+
+## 1. Gather
+
+The gather phases has three responsibilities:
+
+1. Add all declared symbols to the symbol table.
+2. Set the `scope_id` property of all identifiers and fully-qualified-names.
+3. For the main identifiers of `UseStatement`s (i.e., the last identifier in the `UseStatement`):
+   set a 'linking' symbol on the identifier, which will later be filled in with the linked-to
+   symbol (probably in another file, or from the standard library).
+
+## 2. Resolve
+
+The resolve phase has one main responsibility: resolve all references based on the identifier's
+`scope_id` property.
+*/
+
 use crate::ast::named::Named;
 use crate::ast::CompilationUnit;
 use crate::diagnostic::DmDiagnostic;
@ -43,7 +64,11 @@ mod tests {
    use pest::Parser;
    use std::collections::HashMap;

-    fn assert_no_diagnostics(sources: HashMap<&str, &str>) -> SymbolTable {
+    fn assert_number_of_diagnostics(
+        sources: HashMap<&str, &str>,
+        symbol_table: &mut SymbolTable,
+        n_diagnostics: usize,
+    ) {
        let mut files = SimpleFiles::new();
        let mut compilation_units = vec![];

@ -61,10 +86,7 @@ mod tests {
            compilation_units.push(build_ast(file_name, file_id, pairs.next().unwrap()))
        }

-        let mut symbol_table = SymbolTable::new();
-        add_std_core_symbols(&mut symbol_table).expect("Failed to add std_core_symbols");
-
-        let diagnostics = analyze_names(&mut compilation_units, &mut symbol_table);
+        let diagnostics = analyze_names(&mut compilation_units, symbol_table);

        if !diagnostics.is_empty() {
            let writer = StandardStream::stderr(ColorChoice::Always);
@ -75,14 +97,17 @@ mod tests {
            }

            eprintln!("{}", symbol_table);
-            panic!("Diagnostics was not empty!");
        }

+        assert_eq!(n_diagnostics, diagnostics.len());
+
        for compilation_unit in &compilation_units {
            dbg!(compilation_unit);
        }
+    }

-        symbol_table
+    fn assert_no_diagnostics(sources: HashMap<&str, &str>, symbol_table: &mut SymbolTable) {
+        assert_number_of_diagnostics(sources, symbol_table, 0);
    }

    #[test]
@ -95,7 +120,7 @@ mod tests {
            }"},
        )]);

-        assert_no_diagnostics(sources);
+        assert_no_diagnostics(sources, &mut SymbolTable::new());
    }

    #[test]
@ -105,10 +130,6 @@ mod tests {
                "main.dm",
                indoc! {"
                use test::Greeter;
-
-                fn main(args: Array<String>) {
-                    println(\"Hello, World!\");
-                }
            "},
            ),
            (
@ -121,6 +142,81 @@ mod tests {
            ),
        ]);

-        assert_no_diagnostics(sources);
+        assert_no_diagnostics(sources, &mut SymbolTable::new());
+    }
+
+    #[test]
+    fn sees_std_core_println() {
+        let sources: HashMap<&str, &str> = HashMap::from([(
+            "main.dm",
+            indoc! {"
+                fn main(args: Array<String>) {
+                    println(args)
+                }
+            "},
+        )]);
+
+        let mut symbol_table = SymbolTable::new();
+        add_std_core_symbols(&mut symbol_table).expect("Failed to add std::core symbols.");
+        assert_no_diagnostics(sources, &mut symbol_table);
+    }
+
+    #[test]
+    fn sees_duplicate_fn() {
+        let sources: HashMap<&str, &str> = HashMap::from([(
+            "main.dm",
+            indoc! {"
+                fn main(args: Array<String>) {}
+                fn main(args: Array<String>) {}
+            "},
+        )]);
+        assert_number_of_diagnostics(sources, &mut SymbolTable::new(), 1);
+    }
+
+    #[test]
+    fn use_class_from_other_file() {
+        let sources: HashMap<&str, &str> = HashMap::from([
+            (
+                "main.dm",
+                indoc! {"
+                    use greeter::Greeter;
+
+                    fn test(greeter: Greeter) {}
+                "},
+            ),
+            (
+                "greeter.dm",
+                indoc! {"
+                    ns greeter;
+
+                    class Greeter {}
+                "},
+            ),
+        ]);
+        let mut symbol_table = SymbolTable::new();
+        assert_no_diagnostics(sources, &mut symbol_table);
+    }
+    
+    #[test]
+    fn shadow_import() {
+        let sources: HashMap<&str, &str> = HashMap::from([
+            (
+                "main.dm",
+                indoc! {"
+                    use greeter::Greeter;
+
+                    class Greeter {}
+                "}
+            ),
+            (
+                "greeter.dm",
+                indoc! {"
+                    ns greeter;
+
+                    class Greeter {}
+                "}
+            )
+        ]);
+        assert_number_of_diagnostics(sources, &mut SymbolTable::new(), 1);
    }
 }
--- a/src/name_analysis/resolve.rs
+++ b/src/name_analysis/resolve.rs
@ -1,38 +1,14 @@
 use crate::ast::named::Named;
 use crate::ast::*;
 use crate::diagnostic::DmDiagnostic;
-use crate::name_analysis::symbol_table::SymbolTable;
+use crate::name_analysis::symbol::Symbol;
+use crate::name_analysis::symbol_table::{SymbolLookupError, SymbolTable};
 use codespan_reporting::diagnostic::{Diagnostic, Label};
+use std::cell::RefCell;
+use std::range::Range;
+use std::rc::Rc;

-fn resolve_fully_qualified_name(
-    fully_qualified_name: &mut FullyQualifiedName,
-    symbol_table: &mut SymbolTable,
-    diagnostics: &mut Vec<DmDiagnostic>,
-) {
-    let lookup_result = symbol_table.lookup(
-        fully_qualified_name.name().as_ref(),
-        fully_qualified_name.scope_id().expect(&format!(
-            "FullyQualifiedName has no scope_id set: {:?}",
-            fully_qualified_name
-        )),
-    );
-    match lookup_result {
-        Ok(symbol) => {
-            fully_qualified_name.set_symbol(symbol.clone());
-        }
-        Err(e) => diagnostics.push(
-            Diagnostic::error()
-                .with_message(format!(
-                    "No symbol with name '{}' found in current scope.",
-                    fully_qualified_name.name()
-                ))
-                .with_label(Label::primary(
-                    fully_qualified_name.file_id,
-                    fully_qualified_name.range,
-                )),
-        ),
-    }
-}
+/* Type Use */

 fn resolve_type_use(
    type_use: &mut TypeUse,
@ -40,7 +16,9 @@ fn resolve_type_use(
    diagnostics: &mut Vec<DmDiagnostic>,
 ) {
    match type_use {
-        TypeUse::Void => {}
+        TypeUse::Primitive(primitive_type_use) => {
+            resolve_primitive_type_use(primitive_type_use, symbol_table, diagnostics)
+        }
        TypeUse::InterfaceOrClass(interface_or_class_type_use) => {
            resolve_interface_or_class_type_use(
                interface_or_class_type_use,
@ -57,16 +35,56 @@ fn resolve_type_use(
    }
 }

+fn resolve_primitive_type_use(
+    primitive_type_use: &mut PrimitiveTypeUse,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    match primitive_type_use {
+        PrimitiveTypeUse::Array(generic_arguments_opt) => {
+            if let Some(generic_arguments) = generic_arguments_opt {
+                resolve_generic_arguments(generic_arguments, symbol_table, diagnostics);
+            }
+        }
+        _ => {}
+    }
+}
+
 fn resolve_interface_or_class_type_use(
    interface_or_class_type_use: &mut InterfaceOrClassTypeUse,
    symbol_table: &mut SymbolTable,
    diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_fully_qualified_name(
-        &mut interface_or_class_type_use.fqn,
-        symbol_table,
-        diagnostics,
-    );
+    // 1. handle main name
+    let fqn = &mut interface_or_class_type_use.fqn;
+    let lookup_result = if fqn.is_single_identifier() {
+        let identifier = fqn.last();
+        symbol_table.lookup_type_by_declared_name(
+            &identifier.name(),
+            identifier
+                .scope_id()
+                .expect("Identifier's scope id not set."),
+        )
+    } else {
+        todo!("Fully-qualified-name type uses sensitive to imports and so on")
+    };
+    match lookup_result {
+        Ok(type_symbol) => {
+            fqn.last_mut().set_saved_symbol(Symbol::Type(type_symbol));
+        }
+        Err(_) => {
+            diagnostics.push(
+                Diagnostic::error()
+                    .with_message(&format!(
+                        "No type symbol '{}' found in current scope.",
+                        fqn.name()
+                    ))
+                    .with_label(Label::primary(fqn.file_id(), fqn.range())),
+            );
+        }
+    }
+
+    // 2. generics
    resolve_generic_arguments(
        &mut interface_or_class_type_use.generics,
        symbol_table,
@ -95,6 +113,8 @@ fn resolve_function_type_use(
    );
 }

+/* Generic arguments */
+
 fn resolve_generic_arguments(
    generic_arguments: &mut GenericArguments,
    symbol_table: &mut SymbolTable,
@ -105,6 +125,10 @@ fn resolve_generic_arguments(
    }
 }

+/* Generic parameters: todo: no resolution needed? */
+
+/* Tuple arguments */
+
 fn resolve_tuple_arguments(
    tuple_type_use: &mut TupleArguments,
    symbol_table: &mut SymbolTable,
@ -115,6 +139,8 @@ fn resolve_tuple_arguments(
    }
 }

+/* Implements list */
+
 fn resolve_implements_list(
    implements_list: &mut ImplementsList,
    symbol_table: &mut SymbolTable,
@ -123,6 +149,8 @@ fn resolve_implements_list(
    todo!()
 }

+/* Function parameters */
+
 fn resolve_parameters(
    parameters: &mut Parameters,
    symbol_table: &mut SymbolTable,
@ -133,6 +161,8 @@ fn resolve_parameters(
    }
 }

+/* Return Type */
+
 fn resolve_return_type(
    return_type: &mut ReturnType,
    symbol_table: &mut SymbolTable,
@ -142,6 +172,8 @@ fn resolve_return_type(
    resolve_references(&mut return_type.references, symbol_table, diagnostics);
 }

+/* References */
+
 fn resolve_references(
    references: &mut References,
    symbol_table: &mut SymbolTable,
@ -152,46 +184,7 @@ fn resolve_references(
    }
 }

-fn resolve_use_statement(
-    use_statement: &mut UseStatement,
-    symbol_table: &mut SymbolTable,
-    diagnostics: &mut Vec<DmDiagnostic>,
-) {
-    if use_statement.is_star() {
-        todo!()
-    }
-
-    let base_name = use_statement.base_name().to_string();
-
-    match &use_statement.last {
-        UseStatementLast::Identifier(identifier) => {
-            let borrowed_identifier = identifier.borrow();
-            let declared_name = borrowed_identifier.name().to_string();
-            let fqn = format!("{}::{}", &base_name, &declared_name);
-            let lookup_result =
-                symbol_table.lookup_usable_by_fqn(&fqn, borrowed_identifier.scope_id().unwrap());
-            drop(borrowed_identifier);
-
-            if let Err(_) = lookup_result {
-                diagnostics.push(
-                    Diagnostic::error()
-                        .with_message(&format!("Unable to find symbol '{}'.", fqn))
-                        .with_label(Label::primary(use_statement.file_id, use_statement.range)),
-                );
-            } else {
-                let mut mutable_borrowed_identifier = identifier.borrow_mut();
-                let use_statement_symbol = mutable_borrowed_identifier
-                    .symbol_mut()
-                    .unwrap()
-                    .unwrap_use_statement_symbol();
-                let mut mutable_borrowed_use_statement_symbol = use_statement_symbol.borrow_mut();
-                mutable_borrowed_use_statement_symbol.set_referenced_symbol(lookup_result.unwrap())
-            }
-        }
-        UseStatementLast::Identifiers(identifiers) => {}
-        UseStatementLast::Star => panic!(),
-    }
-}
+/* Compilation Unit/Top-level construct */

 pub(super) fn resolve_compilation_unit(
    compilation_unit: &mut CompilationUnit,
@ -206,7 +199,79 @@ pub(super) fn resolve_compilation_unit(
    }
 }

-pub(super) fn resolve_module_level_declaration(
+/* Use Statement */
+
+fn handle_use_statement_identifier(
+    identifier: Rc<RefCell<Identifier>>,
+    base_name: &str,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+    file_id: usize,
+    error_range: Range<usize>,
+) {
+    let borrowed_identifier = identifier.borrow();
+    let declared_name = borrowed_identifier.name().to_string();
+    let fqn = format!("{}::{}", base_name, &declared_name);
+    let lookup_result =
+        symbol_table.lookup_usable_by_fqn(&fqn, borrowed_identifier.scope_id().unwrap());
+
+    match lookup_result {
+        Ok(referenced_symbol) => {
+            let saved_symbol = borrowed_identifier
+                .saved_symbol()
+                .expect("Identifier's saved_symbol is not set.");
+            let use_statement_symbol = saved_symbol.unwrap_use_statement_symbol();
+            use_statement_symbol
+                .borrow_mut()
+                .set_referenced_symbol(referenced_symbol);
+        }
+        Err(_) => {
+            diagnostics.push(
+                Diagnostic::error()
+                    .with_message(&format!("Unable to find symbol '{}'.", fqn))
+                    .with_label(Label::primary(file_id, error_range)),
+            );
+        }
+    }
+}
+
+fn resolve_use_statement(
+    use_statement: &mut UseStatement,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let base_name = use_statement.base_name().to_string();
+
+    match &use_statement.last {
+        UseStatementLast::Identifier(identifier) => {
+            handle_use_statement_identifier(
+                identifier.clone(),
+                &base_name,
+                symbol_table,
+                diagnostics,
+                use_statement.file_id,
+                use_statement.range,
+            );
+        }
+        UseStatementLast::Identifiers(identifiers) => {
+            for identifier in identifiers {
+                handle_use_statement_identifier(
+                    identifier.clone(),
+                    &base_name,
+                    symbol_table,
+                    diagnostics,
+                    use_statement.file_id,
+                    identifier.borrow().range(),
+                )
+            }
+        }
+        UseStatementLast::Star => todo!("star imports"),
+    }
+}
+
+/* Declarations allowed in each level */
+
+fn resolve_module_level_declaration(
    declaration: &mut ModuleLevelDeclaration,
    symbol_table: &mut SymbolTable,
    diagnostics: &mut Vec<DmDiagnostic>,
@ -228,6 +293,65 @@ pub(super) fn resolve_module_level_declaration(
    }
 }

+fn resolve_interface_level_declaration(
+    declaration: &mut InterfaceLevelDeclaration,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn resolve_class_level_declaration(
+    declaration: &mut ClassLevelDeclaration,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+/* Main Declarations */
+
+fn resolve_module_declaration(
+    module_declaration: &mut ModuleDeclaration,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    for declaration in &mut module_declaration.declarations {
+        resolve_module_level_declaration(declaration, symbol_table, diagnostics);
+    }
+}
+
+fn resolve_interface_declaration(
+    interface_declaration: &mut InterfaceDeclaration,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    resolve_implements_list(
+        &mut interface_declaration.implements,
+        symbol_table,
+        diagnostics,
+    );
+    for declaration in &mut interface_declaration.declarations {
+        resolve_interface_level_declaration(declaration, symbol_table, diagnostics);
+    }
+}
+
+fn resolve_class_declaration(
+    class_declaration: &mut ClassDeclaration,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    if let Some(class_constructor) = &mut class_declaration.class_constructor {
+        resolve_class_constructor(class_constructor, symbol_table, diagnostics);
+    }
+    resolve_implements_list(&mut class_declaration.implements, symbol_table, diagnostics);
+    for declaration in &mut class_declaration.declarations {
+        resolve_class_level_declaration(declaration, symbol_table, diagnostics);
+    }
+}
+
+/* Function declarations and components */
+
 fn resolve_function_definition(
    function_definition: &mut FunctionDefinition,
    symbol_table: &mut SymbolTable,
@ -246,6 +370,14 @@ fn resolve_function_definition(
    resolve_function_body(&mut function_definition.body, symbol_table, diagnostics);
 }

+fn resolve_operator_function_definition(
+    operator_function_definition: &mut OperatorFunctionDefinition,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
 fn resolve_platform_function_declaration(
    platform_function_declaration: &mut PlatformFunctionDeclaration,
    symbol_table: &mut SymbolTable,
@ -263,6 +395,22 @@ fn resolve_platform_function_declaration(
    );
 }

+fn resolve_interface_function_declaration(
+    interface_function_declaration: &mut InterfaceFunctionDeclaration,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn resolve_interface_operator_function_declaration(
+    interface_operator_function_declaration: &mut InterfaceOperatorFunctionDeclaration,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
 fn resolve_function_body(
    function_body: &mut FunctionBody,
    symbol_table: &mut SymbolTable,
@ -270,12 +418,49 @@ fn resolve_function_body(
 ) {
    use crate::ast::FunctionBody::*;
    match function_body {
-        Block(block) => resolve_block(block, symbol_table, diagnostics),
-        _ => todo!(),
+        Equals(expression) => resolve_expression(expression, symbol_table, diagnostics),
+        Block(block) => resolve_block_statement(block, symbol_table, diagnostics),
+        Alias(identifier) => resolve_function_alias(identifier, symbol_table, diagnostics),
    }
 }

-fn resolve_block(
+fn resolve_function_alias(
+    identifier: &mut Identifier,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+/* Class components */
+
+fn resolve_class_constructor(
+    class_constructor: &mut ClassConstructor,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn resolve_property_declaration(
+    property_declaration: &mut PropertyDeclaration,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn resolve_field_declaration(
+    field_declaration: &mut FieldDeclaration,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+/* Statements */
+
+fn resolve_block_statement(
    block_statement: &mut BlockStatement,
    symbol_table: &mut SymbolTable,
    diagnostics: &mut Vec<DmDiagnostic>,
@ -295,7 +480,7 @@ fn resolve_statement(
 ) {
    use crate::ast::Statement::*;
    match statement {
-        BlockStatement(block) => resolve_block(block, symbol_table, diagnostics),
+        BlockStatement(block) => resolve_block_statement(block, symbol_table, diagnostics),
        VariableDeclarationStatement(variable_declaration) => {
            resolve_variable_declaration(variable_declaration, symbol_table, diagnostics)
        }
@ -336,6 +521,42 @@ fn resolve_call_statement(
    resolve_expression(&mut call_statement.0, symbol_table, diagnostics)
 }

+fn resolve_return_statement(
+    return_statement: &mut ReturnStatement,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    if let Some(expression) = &mut return_statement.0 {
+        resolve_expression(expression, symbol_table, diagnostics);
+    }
+}
+
+fn resolve_if_statement(
+    if_statement: &mut IfStatement,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn resolve_while_statement(
+    while_statement: &mut WhileStatement,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+fn resolve_for_statement(
+    for_statement: &mut ForStatement,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    todo!()
+}
+
+/* Expressions */
+
 fn resolve_expression(
    expression: &mut Expression,
    symbol_table: &mut SymbolTable,
@ -361,7 +582,13 @@ fn resolve_expression(
        ObjectAccess(object_access) => {
            resolve_object_access(object_access, symbol_table, diagnostics);
        }
-        FullyQualifiedName(fqn) => resolve_fully_qualified_name(fqn, symbol_table, diagnostics),
+        FullyQualifiedName(fqn) => {
+            if fqn.is_single_identifier() {
+                resolve_identifier_expression(fqn.last_mut(), symbol_table, diagnostics);
+            } else {
+                resolve_fqn_expression(fqn, symbol_table, diagnostics);
+            }
+        }
        Literal(literal) => {
            resolve_literal(literal, symbol_table, diagnostics);
        }
@ -371,6 +598,48 @@ fn resolve_expression(
    }
 }

+fn handle_named_lookup_result(
+    lookup_result: Result<Symbol, SymbolLookupError>,
+    named: &mut impl Named,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    match lookup_result {
+        Ok(referenced_symbol) => {
+            named.set_saved_symbol(referenced_symbol);
+        }
+        Err(_) => {
+            diagnostics.push(
+                DmDiagnostic::error()
+                    .with_message(&format!(
+                        "Unable to find expressible symbol {} in current scope.",
+                        named.name()
+                    ))
+                    .with_label(Label::primary(named.file_id(), named.range())),
+            );
+        }
+    }
+}
+
+fn resolve_identifier_expression(
+    identifier: &mut Identifier,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let lookup_result = symbol_table
+        .lookup_expressible_by_declared_name(&identifier.name(), identifier.scope_id().unwrap());
+    handle_named_lookup_result(lookup_result, identifier, diagnostics);
+}
+
+fn resolve_fqn_expression(
+    fqn: &mut FullyQualifiedName,
+    symbol_table: &mut SymbolTable,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let lookup_result =
+        symbol_table.lookup_expressible_by_fqn(&fqn.name(), fqn.last().scope_id().unwrap());
+    handle_named_lookup_result(lookup_result, fqn, diagnostics);
+}
+
 fn resolve_ternary_expression(
    ternary_expression: &mut TernaryExpression,
    symbol_table: &mut SymbolTable,
@ -431,7 +700,7 @@ fn resolve_turbo_fish(
    symbol_table: &mut SymbolTable,
    diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    todo!()
+    resolve_generic_arguments(&mut turbo_fish.0, symbol_table, diagnostics);
 }

 fn resolve_call_arguments(
--- a/src/name_analysis/symbol.rs
+++ b/src/name_analysis/symbol.rs
@ -1,8 +1,9 @@
-use std::cell::RefCell;
 use crate::ast::{Identifier, UseStatement};
-use std::fmt::Display;
+use std::cell::RefCell;
+use std::fmt::{Debug, Display, Formatter};
 use std::range::Range;
 use std::rc::Rc;
+use crate::ast::named::Named;

 #[derive(Clone, Debug)]
 pub struct SourceDefinition {
@ -13,16 +14,16 @@ pub struct SourceDefinition {
 impl SourceDefinition {
    pub fn from_identifier(identifier: &Identifier) -> Self {
        SourceDefinition {
-            file_id: identifier.file_id,
-            range: identifier.range,
+            file_id: identifier.file_id(),
+            range: identifier.range(),
        }
    }

    pub fn from_identifier_rc(identifier: Rc<RefCell<Identifier>>) -> Self {
        let borrowed = identifier.borrow();
        SourceDefinition {
-            file_id: borrowed.file_id,
-            range: borrowed.range,
+            file_id: borrowed.file_id(),
+            range: borrowed.range(),
        }
    }

@ -55,7 +56,7 @@ pub enum Symbol {
    UseStatement(Rc<RefCell<UseStatementSymbol>>),
    Module(Rc<ModuleSymbol>),
    Type(Rc<TypeSymbol>),
-    Function(Rc<FunctionSymbol>),
+    Function(Rc<RefCell<FunctionSymbol>>),
    Parameter(Rc<ParameterSymbol>),
    Variable(Rc<VariableSymbol>),
 }
@ -63,10 +64,10 @@ pub enum Symbol {
 impl Symbol {
    pub fn definition(&self) -> Option<SourceDefinition> {
        match self {
-            Symbol::UseStatement(s) => s.borrow().definition.clone(),
+            Symbol::UseStatement(s) => s.borrow().definition(),
            Symbol::Module(s) => s.definition(),
            Symbol::Type(s) => s.definition(),
-            Symbol::Function(s) => s.definition(),
+            Symbol::Function(s) => s.borrow().definition(),
            Symbol::Parameter(s) => s.definition(),
            Symbol::Variable(s) => s.definition(),
        }
@ -80,32 +81,21 @@ impl Symbol {
    }
 }

-impl Display for Symbol {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        use Symbol::*;
-        match self {
-            UseStatement(use_statement_symbol) => write!(f, "{}", use_statement_symbol.borrow()),
-            Module(module_symbol) => write!(f, "{}", module_symbol),
-            Type(class_symbol) => write!(f, "{}", class_symbol),
-            Function(function_symbol) => write!(f, "{}", function_symbol),
-            Parameter(parameter_symbol) => write!(f, "{}", parameter_symbol),
-            Variable(variable_symbol) => write!(f, "{}", variable_symbol),
-        }
-    }
-}
-
 /* Use-statement */

-#[derive(Debug, Clone)]
 pub struct UseStatementSymbol {
    pub fqn: String,
    pub declared_name: String,
    definition: Option<SourceDefinition>,
-    referenced_symbol: Option<Box<Symbol>>
+    referenced_symbol: Option<Box<Symbol>>,
 }

 impl UseStatementSymbol {
-    pub fn new(fqn: &str, declared_name: &str, identifier: Option<Rc<RefCell<Identifier>>>) -> Self {
+    pub fn new(
+        fqn: &str,
+        declared_name: &str,
+        identifier: Option<Rc<RefCell<Identifier>>>,
+    ) -> Self {
        UseStatementSymbol {
            fqn: fqn.to_string(),
            declared_name: declared_name.to_string(),
@ -133,20 +123,18 @@ impl SymbolInner for UseStatementSymbol {
    }
 }

-impl Display for UseStatementSymbol {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "UseStatementSymbol(fqn = {}, declared_name = {})",
-            self.fqn, self.declared_name
-        )
+impl Debug for UseStatementSymbol {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("UseStatementSymbol")
+            .field("fqn", &self.fqn)
+            .field("declared_name", &self.declared_name)
+            .field("referenced_symbol", &self.referenced_symbol)
+            .finish()
    }
 }

-
 /* Module */

-#[derive(Debug)]
 pub struct ModuleSymbol {
    fqn: String,
    declared_name: String,
@ -180,19 +168,18 @@ impl SymbolInner for ModuleSymbol {
    }
 }

-impl Display for ModuleSymbol {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "ModuleSymbol(name = {}, is_public = {})",
-            self.fqn, self.is_public
-        )
+impl Debug for ModuleSymbol {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ModuleSymbol")
+            .field("fqn", &self.fqn)
+            .field("declared_name", &self.declared_name)
+            .field("is_public", &self.is_public)
+            .finish()
    }
 }

-/* Class */
+/* TypeSymbol */

-#[derive(Debug)]
 pub struct TypeSymbol {
    fqn: String,
    declared_name: String,
@ -201,7 +188,12 @@ pub struct TypeSymbol {
 }

 impl TypeSymbol {
-    pub fn new(fqn: &str, declared_name: &str, is_public: bool, identifier: Option<&Identifier>) -> Self {
+    pub fn new(
+        fqn: &str,
+        declared_name: &str,
+        is_public: bool,
+        identifier: Option<&Identifier>,
+    ) -> Self {
        TypeSymbol {
            fqn: fqn.to_string(),
            declared_name: declared_name.to_string(),
@ -229,25 +221,26 @@ impl SymbolInner for TypeSymbol {
    }
 }

-impl Display for TypeSymbol {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "TypeSymbol(fqn = {}, declared_name = {})",
-            self.fqn, self.declared_name
-        )
+impl Debug for TypeSymbol {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TypeSymbol")
+            .field("fqn", &self.fqn)
+            .field("declared_name", &self.declared_name)
+            .field("is_public", &self.is_public)
+            .finish()
    }
 }

 /* Function */

-#[derive(Debug)]
 pub struct FunctionSymbol {
    fqn: String,
    declared_name: String,
    is_public: bool,
    is_platform: bool,
    definition: Option<SourceDefinition>,
+    parameters: Vec<Rc<ParameterSymbol>>,
+    return_type: Option<Rc<TypeSymbol>>,
 }

 impl FunctionSymbol {
@ -264,12 +257,49 @@ impl FunctionSymbol {
            is_public,
            is_platform,
            definition: identifier.map(SourceDefinition::from_identifier),
+            parameters: Vec::new(),
+            return_type: None,
+        }
+    }
+
+    pub fn with_parameters(self, parameters: Vec<ParameterSymbol>) -> Self {
+        Self {
+            fqn: self.fqn,
+            declared_name: self.declared_name,
+            is_public: self.is_public,
+            is_platform: self.is_platform,
+            definition: self.definition,
+            parameters: parameters
+                .into_iter()
+                .map(|parameter| Rc::new(parameter))
+                .collect(),
+            return_type: self.return_type,
+        }
+    }
+
+    pub fn with_return_type(self, return_type: TypeSymbol) -> Self {
+        Self {
+            fqn: self.fqn,
+            declared_name: self.declared_name,
+            is_public: self.is_public,
+            is_platform: self.is_platform,
+            definition: self.definition,
+            parameters: self.parameters,
+            return_type: Some(Rc::new(return_type)),
        }
    }

    pub fn fqn(&self) -> &str {
        &self.fqn
    }
+
+    pub fn set_parameters(&mut self, parameters: Vec<Rc<ParameterSymbol>>) {
+        self.parameters = parameters;
+    }
+
+    pub fn set_return_type(&mut self, return_type: Rc<TypeSymbol>) {
+        self.return_type = Some(return_type);
+    }
 }

 impl SymbolInner for FunctionSymbol {
@ -282,19 +312,21 @@ impl SymbolInner for FunctionSymbol {
    }
 }

-impl Display for FunctionSymbol {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "FunctionSymbol(fqn = {}, declared_name = {}, is_public = {})",
-            self.fqn, self.declared_name, self.is_public
-        )
+impl Debug for FunctionSymbol {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FunctionSymbol")
+            .field("fqn", &self.fqn)
+            .field("declared_name", &self.declared_name)
+            .field("is_public", &self.is_public)
+            .field("is_platform", &self.is_platform)
+            .field("parameters", &self.parameters)
+            .field("return_type", &self.return_type)
+            .finish()
    }
 }

 /* Parameter */

-#[derive(Debug)]
 pub struct ParameterSymbol {
    declared_name: String,
    definition: Option<SourceDefinition>,
@ -319,19 +351,16 @@ impl SymbolInner for ParameterSymbol {
    }
 }

-impl Display for ParameterSymbol {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "ParameterSymbol({})",
-            self.declared_name
-        )
+impl Debug for ParameterSymbol {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ParameterSymbol")
+            .field("declared_name", &self.declared_name)
+            .finish()
    }
 }

 /* Variable */

-#[derive(Debug)]
 pub struct VariableSymbol {
    declared_name: String,
    is_mutable: bool,
@ -358,12 +387,11 @@ impl SymbolInner for VariableSymbol {
    }
 }

-impl Display for VariableSymbol {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(
-            f,
-            "VariableSymbol(name = {}, is_mutable = {})",
-            self.declared_name, self.is_mutable
-        )
+impl Debug for VariableSymbol {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VariableSymbol")
+            .field("declared_name", &self.declared_name)
+            .field("is_mutable", &self.is_mutable)
+            .finish()
    }
 }
--- a/src/name_analysis/symbol_table.rs
+++ b/src/name_analysis/symbol_table.rs
@ -1,10 +1,10 @@
-use std::cell::RefCell;
 use crate::name_analysis::symbol::{
    FunctionSymbol, ModuleSymbol, ParameterSymbol, Symbol, SymbolInner, TypeSymbol,
    UseStatementSymbol, VariableSymbol,
 };
 use crate::name_analysis::symbol_table::SymbolInsertError::SymbolAlreadyDefined;
 use crate::name_analysis::symbol_table::SymbolLookupError::NoDefinition;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt::Display;
 use std::rc::Rc;
@ -16,7 +16,7 @@ struct Scope {
    use_statement_symbols: HashMap<String, Rc<RefCell<UseStatementSymbol>>>,
    module_symbols: HashMap<String, Rc<ModuleSymbol>>,
    type_symbols: HashMap<String, Rc<TypeSymbol>>,
-    function_symbols: HashMap<String, Rc<FunctionSymbol>>,
+    function_symbols: HashMap<String, Rc<RefCell<FunctionSymbol>>>,
    parameter_symbols: HashMap<String, Rc<ParameterSymbol>>,
    variable_symbols: HashMap<String, Rc<VariableSymbol>>,
    debug_name: String,
@ -37,13 +37,34 @@ impl Scope {
    }

    fn get_any_symbol(&self, name: &str) -> Option<Symbol> {
-        self.variable_symbols.get(name)
+        self.variable_symbols
+            .get(name)
            .map(|s| Symbol::Variable(s.clone()))
-            .or_else(|| self.parameter_symbols.get(name).map(|s| Symbol::Parameter(s.clone())))
-            .or_else(|| self.function_symbols.get(name).map(|s| Symbol::Function(s.clone())))
-            .or_else(|| self.type_symbols.get(name).map(|ts| Symbol::Type(ts.clone())))
-            .or_else(|| self.module_symbols.get(name).map(|ms| Symbol::Module(ms.clone())))
-            .or_else(|| self.use_statement_symbols.get(name).map(|us| Symbol::UseStatement(us.clone())))
+            .or_else(|| {
+                self.parameter_symbols
+                    .get(name)
+                    .map(|s| Symbol::Parameter(s.clone()))
+            })
+            .or_else(|| {
+                self.function_symbols
+                    .get(name)
+                    .map(|s| Symbol::Function(s.clone()))
+            })
+            .or_else(|| {
+                self.type_symbols
+                    .get(name)
+                    .map(|ts| Symbol::Type(ts.clone()))
+            })
+            .or_else(|| {
+                self.module_symbols
+                    .get(name)
+                    .map(|ms| Symbol::Module(ms.clone()))
+            })
+            .or_else(|| {
+                self.use_statement_symbols
+                    .get(name)
+                    .map(|us| Symbol::UseStatement(us.clone()))
+            })
    }

    fn get_module_symbol_by_declared_name(&self, name: &str) -> Option<Rc<ModuleSymbol>> {
@ -55,9 +76,32 @@ impl Scope {
        None
    }

+    fn get_type_symbol_by_declared_name(&self, declared_name: &str) -> Option<Rc<TypeSymbol>> {
+        if let Some(type_symbol) = self.type_symbols.get(declared_name) {
+            Some(type_symbol.clone())
+        } else {
+            for use_statement_symbol in self.use_statement_symbols.values() {
+                let borrowed = use_statement_symbol.borrow();
+                if borrowed.declared_name() == declared_name {
+                    if let Some(referenced_symbol) = borrowed.referenced_symbol() {
+                        match *referenced_symbol {
+                            Symbol::Type(type_symbol) => return Some(type_symbol.clone()),
+                            _ => continue,
+                        }
+                    }
+                }
+            }
+            None
+        }
+    }
+
+    fn get_type_symbol_by_fqn(&self, fqn: &str) -> Option<Rc<TypeSymbol>> {
+        self.type_symbols.values().find(|s| s.fqn() == fqn).cloned()
+    }
+
    fn get_usable_symbol_by_fqn(&self, fqn: &str) -> Option<Symbol> {
        for function_symbol in self.function_symbols.values() {
-            if function_symbol.fqn() == fqn {
+            if function_symbol.borrow().fqn() == fqn {
                return Some(Symbol::Function(function_symbol.clone()));
            }
        }
@ -71,7 +115,7 @@ impl Scope {

    fn get_usable_symbol_by_declared_name(&self, declared_name: &str) -> Option<Symbol> {
        for function_symbol in self.function_symbols.values() {
-            if function_symbol.declared_name() == declared_name {
+            if function_symbol.borrow().declared_name() == declared_name {
                return Some(Symbol::Function(function_symbol.clone()));
            }
        }
@ -96,6 +140,45 @@ impl Scope {
        }
        None
    }
+
+    fn get_expressible_by_declared_name(&self, declared_name: &str) -> Option<Symbol> {
+        self.variable_symbols
+            .get(declared_name)
+            .map(|s| Symbol::Variable(s.clone()))
+            .or_else(|| {
+                self.parameter_symbols
+                    .get(declared_name)
+                    .map(|p| Symbol::Parameter(p.clone()))
+            })
+            .or_else(|| {
+                self.function_symbols
+                    .get(declared_name)
+                    .map(|f| Symbol::Function(f.clone()))
+            })
+            .or_else(|| {
+                self.type_symbols
+                    .get(declared_name)
+                    .map(|t| Symbol::Type(t.clone()))
+            })
+            .or_else(|| {
+                self.use_statement_symbols
+                    .get(declared_name)
+                    .map(|us| Symbol::UseStatement(us.clone()))
+            })
+    }
+
+    fn get_expressible_by_fqn(&self, fqn: &str) -> Option<Symbol> {
+        self.function_symbols
+            .values()
+            .find(|fs| fs.borrow().fqn() == fqn)
+            .map(|f| Symbol::Function(f.clone()))
+            .or_else(|| {
+                self.type_symbols
+                    .values()
+                    .find(|ts| ts.fqn() == fqn)
+                    .map(|ts| Symbol::Type(ts.clone()))
+            })
+    }
 }

 /* Symbol table */
@ -152,18 +235,20 @@ impl SymbolTable {
    pub fn insert_use_statement_symbol(
        &mut self,
        use_statement_symbol: UseStatementSymbol,
-    ) -> Result<(), SymbolInsertError> {
+    ) -> Result<Rc<RefCell<UseStatementSymbol>>, SymbolInsertError> {
        let current_scope = self.scopes.get_mut(self.current_scope_id).unwrap();
        if let Some(defined_symbol) =
            current_scope.get_usable_symbol_by_declared_name(use_statement_symbol.declared_name())
        {
            Err(SymbolAlreadyDefined(defined_symbol))
        } else {
-            current_scope.use_statement_symbols.insert(
-                use_statement_symbol.declared_name().to_string(),
-                Rc::new(RefCell::new(use_statement_symbol)),
-            );
-            Ok(())
+            let declared_name = use_statement_symbol.declared_name().to_string();
+            let to_insert = Rc::new(RefCell::new(use_statement_symbol));
+            let to_return = to_insert.clone();
+            current_scope
+                .use_statement_symbols
+                .insert(declared_name, to_insert);
+            Ok(to_return)
        }
    }

@ -203,36 +288,39 @@ impl SymbolTable {
    pub fn insert_function_symbol(
        &mut self,
        function_symbol: FunctionSymbol,
-    ) -> Result<(), SymbolInsertError> {
+    ) -> Result<Rc<RefCell<FunctionSymbol>>, SymbolInsertError> {
        let current_scope = self.scopes.get_mut(self.current_scope_id).unwrap();
        if let Some(defined_symbol) =
            current_scope.get_usable_symbol_by_declared_name(function_symbol.declared_name())
        {
            Err(SymbolAlreadyDefined(defined_symbol))
        } else {
-            current_scope.function_symbols.insert(
-                function_symbol.declared_name().to_string(),
-                Rc::new(function_symbol),
-            );
-            Ok(())
+            let declared_name = function_symbol.declared_name().to_string();
+            let to_insert = Rc::new(RefCell::new(function_symbol));
+            let to_return = to_insert.clone();
+            current_scope
+                .function_symbols
+                .insert(declared_name, to_insert);
+            Ok(to_return)
        }
    }

    pub fn insert_parameter_symbol(
        &mut self,
        parameter_symbol: ParameterSymbol,
-    ) -> Result<(), SymbolInsertError> {
+    ) -> Result<Rc<ParameterSymbol>, SymbolInsertError> {
        let current_scope = self.scopes.get_mut(self.current_scope_id).unwrap();
        if let Some(defined_symbol) =
            current_scope.get_value_symbol_by_declared_name(parameter_symbol.declared_name())
        {
            Err(SymbolAlreadyDefined(defined_symbol))
        } else {
-            current_scope.parameter_symbols.insert(
-                parameter_symbol.declared_name().to_string(),
-                Rc::new(parameter_symbol),
-            );
-            Ok(())
+            let to_insert = Rc::new(parameter_symbol);
+            let to_return = to_insert.clone();
+            current_scope
+                .parameter_symbols
+                .insert(to_insert.declared_name().to_string(), to_insert);
+            Ok(to_return)
        }
    }

@ -254,6 +342,7 @@ impl SymbolTable {
        }
    }

+    #[deprecated(note = "Use more specific lookup methods.")]
    pub fn lookup(&self, name: &str, scope_id: usize) -> Result<Symbol, SymbolLookupError> {
        let mut scope_opt = Some(&self.scopes[scope_id]);
        while let Some(scope) = scope_opt {
@ -269,6 +358,44 @@ impl SymbolTable {
        Err(NoDefinition)
    }

+    pub fn lookup_type_by_declared_name(
+        &self,
+        declared_name: &str,
+        scope_id: usize,
+    ) -> Result<Rc<TypeSymbol>, SymbolLookupError> {
+        let mut scope_opt = Some(&self.scopes[scope_id]);
+        while let Some(scope) = scope_opt {
+            if let Some(symbol) = scope.get_type_symbol_by_declared_name(declared_name) {
+                return Ok(symbol);
+            }
+            scope_opt = if let Some(parent_id) = scope.parent {
+                Some(&self.scopes[parent_id])
+            } else {
+                None
+            }
+        }
+        Err(NoDefinition)
+    }
+
+    pub fn lookup_type_by_fqn(
+        &self,
+        fqn: &str,
+        scope_id: usize,
+    ) -> Result<Rc<TypeSymbol>, SymbolLookupError> {
+        let mut scope_opt = Some(&self.scopes[scope_id]);
+        while let Some(scope) = scope_opt {
+            if let Some(symbol) = scope.get_type_symbol_by_fqn(fqn) {
+                return Ok(symbol);
+            }
+            scope_opt = if let Some(parent_id) = scope.parent {
+                Some(&self.scopes[parent_id])
+            } else {
+                None
+            }
+        }
+        Err(NoDefinition)
+    }
+
    pub fn lookup_usable_by_fqn(
        &self,
        fully_qualified_name: &str,
@ -281,27 +408,68 @@ impl SymbolTable {
        }
        Err(NoDefinition)
    }
+
+    pub fn lookup_expressible_by_declared_name(
+        &self,
+        declared_name: &str,
+        scope_id: usize,
+    ) -> Result<Symbol, SymbolLookupError> {
+        let mut scope_opt = Some(&self.scopes[scope_id]);
+        while let Some(scope) = scope_opt {
+            if let Some(symbol) = scope.get_expressible_by_declared_name(declared_name) {
+                return Ok(symbol);
+            }
+            scope_opt = if let Some(parent_id) = scope.parent {
+                Some(&self.scopes[parent_id])
+            } else {
+                None
+            }
+        }
+        Err(NoDefinition)
+    }
+
+    pub fn lookup_expressible_by_fqn(
+        &self,
+        fqn: &str,
+        scope_id: usize,
+    ) -> Result<Symbol, SymbolLookupError> {
+        let mut scope_opt = Some(&self.scopes[scope_id]);
+        while let Some(scope) = scope_opt {
+            if let Some(symbol) = scope.get_expressible_by_fqn(fqn) {
+                return Ok(symbol);
+            }
+            scope_opt = if let Some(parent_id) = scope.parent {
+                Some(&self.scopes[parent_id])
+            } else {
+                None
+            }
+        }
+        Err(NoDefinition)
+    }
 }

 impl Display for SymbolTable {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        writeln!(f, "SymbolTable(current_scope = {})", self.current_scope_id)?;
        for (i, scope) in self.scopes.iter().enumerate() {
-            writeln!(f, "Scope {} {}", i, scope.debug_name)?;
-            for (name, symbol) in &scope.use_statement_symbols {
-                writeln!(f, "  {}({})", name, symbol.borrow())?;
+            writeln!(f, "----Scope {} {}----", i, scope.debug_name)?;
+            for symbol in scope.use_statement_symbols.values() {
+                writeln!(f, "{:#?}", symbol.borrow())?;
            }
-            for (name, symbol) in &scope.module_symbols {
-                writeln!(f, "  {}({})", name, symbol)?;
+            for symbol in scope.module_symbols.values() {
+                writeln!(f, "{:#?}", symbol)?;
            }
-            for (name, symbol) in &scope.type_symbols {
-                writeln!(f, "  {}({})", name, symbol)?;
+            for symbol in scope.type_symbols.values() {
+                writeln!(f, "{:#?}", symbol)?;
            }
-            for (name, symbol) in &scope.function_symbols {
-                writeln!(f, "  {}({})", name, symbol)?;
+            for symbol in scope.function_symbols.values() {
+                writeln!(f, "{:#?}", symbol.borrow())?;
            }
-            for (name, symbol) in &scope.variable_symbols {
-                writeln!(f, "  {}({})", name, symbol)?;
+            for symbol in scope.parameter_symbols.values() {
+                writeln!(f, "{:#?}", symbol)?;
+            }
+            for symbol in scope.variable_symbols.values() {
+                writeln!(f, "{:#?}", symbol)?;
            }
        }
        Ok(())
--- a/src/parser/deimos.pest
+++ b/src/parser/deimos.pest
@ -2,7 +2,7 @@
 Ns = { "ns" }
 TypeKw = { "type" }
 Mod = { "mod" }
-Int = { "int" }
+IntKw = { "int" }
 ClassKw = { "class" }
 Platform = { "platform" }
 Pub = { "pub" }
@ -15,7 +15,6 @@ Ref = { "ref" }
 Def = { "def" }
 Where = { "where" }
 Infer = { "infer" }
-Void = { "Void" }
 Delegate = { "delegate" }
 Let = { "let" }
 Fn = { "fn" }
@ -32,12 +31,25 @@ True = { "true" }
 False = { "false" }
 Use = { "use" }

+// Keywords: primitive types
+Byte = { "Byte" }
+Short = { "Short" }
+Char = { "Char" }
+Int = { "Int" }
+Long = { "Long" }
+Double = { "Double" }
+Bool = { "Bool" }
+String = { "String" }
+Array = { "Array" }
+Any = { "Any" }
+Void = { "Void" }
+
 // Keywords as a rule (for preventing identifiers with keywords, etc.)
 Keyword = {
      Ns
    | TypeKw
    | Mod
-    | Int
+    | IntKw
    | ClassKw
    | Platform
    | Pub
@ -50,7 +62,6 @@ Keyword = {
    | Def
    | Where
    | Infer
-    | Void
    | Delegate
    | Let
    | Fn
@ -66,6 +77,17 @@ Keyword = {
    | True
    | False
    | Use
+    | Byte
+    | Short
+    | Char
+    | Int
+    | Long
+    | Double
+    | Bool
+    | String
+    | Array
+    | Any
+    | Void
 }

 // Symbols
@ -180,12 +202,26 @@ ParenthesesOptionalTypeUseList = {
 // Parameters = declaration

 TypeUse = {
-      Void
+      PrimitiveType
    | InterfaceOrClassTypeUse
    | TupleTypeUse
    | FunctionTypeUse
 }

+PrimitiveType = {
+        Byte
+      | Short
+      | Char
+      | Int
+      | Long
+      | Double
+      | Bool
+      | String
+      | Array ~ GenericArguments?
+      | Any
+      | Void
+}
+
 InterfaceOrClassTypeUse = {
      Borrow*
    ~ Mut?
@ -335,7 +371,7 @@ Module = {

 Interface = {
      Pub?
-    ~ Int
+    ~ IntKw
    ~ Identifier
    ~ GenericParameters?
    ~ ImplementsList?
--- a/src/std_core/mod.rs
+++ b/src/std_core/mod.rs
@ -1,23 +1,14 @@
-use crate::name_analysis::symbol::{FunctionSymbol, TypeSymbol};
+use crate::name_analysis::symbol::{FunctionSymbol, ParameterSymbol, TypeSymbol};
 use crate::name_analysis::symbol_table::{SymbolInsertError, SymbolTable};

 pub fn add_std_core_symbols(symbol_table: &mut SymbolTable) -> Result<(), SymbolInsertError> {
-    symbol_table.insert_type_symbol(TypeSymbol::new("std::core:Array", "Array", true, None))?;
-    // todo: make this primitive
-    symbol_table.insert_type_symbol(TypeSymbol::new("std::core::String", "String", true, None))?;
-    symbol_table.insert_function_symbol(FunctionSymbol::new(
-        "std::core::println",
-        "println",
-        true,
-        true,
-        None,
-    ))?;
-    symbol_table.insert_function_symbol(FunctionSymbol::new(
-        "std::core::print",
-        "print",
-        true,
-        true,
-        None,
-    ))?;
+    symbol_table.insert_function_symbol(
+        FunctionSymbol::new("std::core::println", "println", true, true, None)
+            .with_parameters(vec![ParameterSymbol::new("msg", None)]),
+    )?;
+    symbol_table.insert_function_symbol(
+        FunctionSymbol::new("std::core::print", "print", true, true, None)
+            .with_parameters(vec![ParameterSymbol::new("msg", None)]),
+    )?;
    Ok(())
 }
Author	SHA1	Message	Date
Jesse Brault	f614d00575	Add shadow import failing test.	2025-05-20 11:11:29 -05:00
Jesse Brault	4c68d0dc28	Flesh out gather and resolve, add todos, refactor a bit.	2025-05-20 11:09:06 -05:00
Jesse Brault	88270e0cdd	Add basic name-analysis phase documentation.	2025-05-20 08:44:26 -05:00
Jesse Brault	02d6a16cf8	Refactor name-analysis tests.	2025-05-19 20:22:13 -05:00
Jesse Brault	0c2d9f8b2f	Add primitive type uses and related.	2025-05-19 13:52:42 -05:00
Jesse Brault	abb7aab3a4	Refactoring of name-analysis.	2025-05-19 09:58:43 -05:00