Introduce scope_ids hash table.

# Conflicts:
#	src/name_analysis/gather.rs

ast-generator/src/deserialize/struct_spec.rs

@@ -151,5 +151,15 @@ pub fn deserialize_struct_spec(name: &str, struct_yaml: &Yaml) -> StructSpec {
     } else {
         deserialize_error!("array", "children", name);
     };
-    StructSpec::new(name, children)
+    let derive = if struct_yaml["derive"].is_array() {
+        struct_yaml["derive"].as_vec()
+            .unwrap()
+            .iter()
+            .map(|derive| derive.as_str().unwrap().to_string())
+            .collect()
+    } else {
+        vec![]
+    };
+    
+    StructSpec::new(name, children, derive)
 }

ast-generator/src/spec/struct_spec.rs

@@ -1,13 +1,15 @@
 pub struct StructSpec {
     build: String,
     children: Vec<Box<StructChild>>,
+    derive: Vec<String>,
 }
 
 impl StructSpec {
-    pub fn new(build: &str, children: Vec<Box<StructChild>>) -> Self {
+    pub fn new(build: &str, children: Vec<Box<StructChild>>, derive: Vec<String>) -> Self {
         Self {
             build: build.to_string(),
             children,
+            derive,
         }
     }
 
@@ -20,6 +22,10 @@ impl StructSpec {
     pub fn children(&self) -> impl Iterator<Item = &StructChild> {
         self.children.iter().map(Box::as_ref)
     }
+    
+    pub fn derive(&self) -> &[String] {
+        &self.derive
+    }
 }
 
 pub enum StructChild {

ast-generator/src/type_gen/struct_type.rs

@@ -205,10 +205,30 @@ pub fn make_struct_type(build_spec: &StructSpec) -> TokenStream {
         .map(Option::unwrap)
         .collect::<Vec<_>>();
 
-    quote! {
+    let struct_stream = {
+        let base = quote! {
             pub struct #type_ident {
                 #(#annotated_members),*
             }
+        };
+        if !build_spec.derive().is_empty() {
+            let derives = build_spec
+                .derive()
+                .iter()
+                .map(|derive| format_ident!("{}", derive))
+                .collect::<Vec<_>>();
+
+            quote! {
+                #[derive(#(#derives,)*)]
+                #base
+            }
+        } else {
+            base
+        }
+    };
+
+    quote! {
+        #struct_stream
 
         impl #type_ident {
             pub fn new(#(#annotated_members),*) -> Self {

src/ast/mod.rs

@@ -1,6 +1,36 @@
 pub mod node {
     include!(concat!(env!("OUT_DIR"), "/src/ast/node.rs"));
 
+    impl OperatorInner {
+        pub fn name(&self) -> &'static str {
+            match self {
+                OperatorInner::Or => "op_or",
+                OperatorInner::And => "op_and",
+                OperatorInner::EqualTo => "op_eq",
+                OperatorInner::NotEqualTo => "op_neq",
+                OperatorInner::Greater => "op_gt",
+                OperatorInner::Less => "op_lt",
+                OperatorInner::GreaterEqual => "op_ge",
+                OperatorInner::LessEqual => "op_le",
+                OperatorInner::Add => "op_add",
+                OperatorInner::Subtract => "op_sub",
+                OperatorInner::Multiply => "op_mul",
+                OperatorInner::Divide => "op_div",
+                OperatorInner::Modulo => "op_mod",
+                OperatorInner::LeftShift => "op_ls",
+                OperatorInner::RightShift => "op_rs",
+                OperatorInner::Spread => "op_spread",
+                OperatorInner::Star => "op_star",
+                OperatorInner::Not => "op_not",
+                OperatorInner::Negative => "op_neg",
+                OperatorInner::PlusPlus => "op_pp",
+                OperatorInner::MinusMinus => "op_mm",
+                OperatorInner::CallOp => "op_call",
+                OperatorInner::Index => "op_index",
+            }
+        }    
+    }
+    
     impl Default for Parameters {
         fn default() -> Self {
             Self::new(vec![])

src/name_analysis/gather.rs

@@ -1,10 +1,13 @@
 use crate::ast::ast_node::{AstNode, AstNodeRef};
 use crate::ast::node::{
-    Class, CompilationUnit, Function, FunctionBlockBody, FunctionBody, Identifier, Interface,
-    Module, Namespace, Statement, UseStatement, UseStatementSuffix, VariableDeclaration,
+    Class, CompilationUnit, Function, FunctionBody, Identifier, Interface,
+    InterfaceDefaultFunction, InterfaceDefaultOperatorFunction, InterfaceFunction,
+    InterfaceOperatorFunction, Member, Module, Namespace, OperatorFunction, PlatformFunction,
+    PlatformOperatorFunction, UseStatement, UseStatementSuffix, VariableDeclaration, VariableUse,
 };
 use crate::diagnostic::DmDiagnostic;
 use crate::name_analysis::fqn_context::FqnContext;
+use crate::name_analysis::symbol::class_member_symbol::ClassMemberSymbol;
 use crate::name_analysis::symbol::function_symbol::FunctionSymbol;
 use crate::name_analysis::symbol::module_symbol::ModuleSymbol;
 use crate::name_analysis::symbol::source_definition::SourceDefinition;
@@ -15,6 +18,7 @@ use crate::name_analysis::symbol::use_symbol::{ConcreteUseSymbol, StarUseSymbol}
 use crate::name_analysis::symbol::variable_symbol::VariableSymbol;
 use crate::name_analysis::symbol_table::{SymbolInsertError, SymbolTable};
 use codespan_reporting::diagnostic::{Diagnostic, Label};
+use std::collections::HashMap;
 use std::range::Range;
 
 fn handle_insert_error(
@@ -53,10 +57,11 @@ fn gather_node_children(
     node: &impl AstNode,
     symbol_table: &mut SymbolTable,
     fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     for child in node.children() {
-        gather_node(child, symbol_table, fqn_context, diagnostics);
+        gather_node(child, symbol_table, fqn_context, scope_ids, diagnostics);
     }
 }
 
@@ -64,12 +69,18 @@ fn gather_node(
     node: AstNodeRef,
     symbol_table: &mut SymbolTable,
     fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     match node {
-        AstNodeRef::Operator(_) => {}
+        AstNodeRef::Operator(_) => {
+            unreachable!();
+        }
+        AstNodeRef::OperatorInner(_) => {
+            unreachable!();
+        }
         AstNodeRef::Identifier(_) => {
-            unreachable!()
+            unreachable!();
         }
         AstNodeRef::FullyQualifiedName(_) => {}
         AstNodeRef::TypeUseList(_) => {}
@@ -89,7 +100,13 @@ fn gather_node(
         AstNodeRef::Parameter(_) => {}
         AstNodeRef::ReturnType(_) => {}
         AstNodeRef::CompilationUnit(compilation_unit) => {
-            gather_node_children(compilation_unit, symbol_table, fqn_context, diagnostics);
+            gather_node_children(
+                compilation_unit,
+                symbol_table,
+                fqn_context,
+                scope_ids,
+                diagnostics,
+            );
         }
         AstNodeRef::Namespace(namespace) => {
             gather_namespace(namespace, fqn_context);
@@ -98,19 +115,20 @@ fn gather_node(
             gather_use_statement(use_statement, symbol_table, diagnostics);
         }
         AstNodeRef::UseStatementPrefix(_) => {
-            unreachable!()
+            unreachable!();
         }
         AstNodeRef::UseStatementSuffix(_) => {
-            unreachable!()
+            unreachable!();
         }
         AstNodeRef::UseList(_) => {
-            unreachable!()
+            unreachable!();
         }
         AstNodeRef::ModuleLevelDeclaration(module_level_declaration) => {
             gather_node_children(
                 module_level_declaration,
                 symbol_table,
                 fqn_context,
+                scope_ids,
                 diagnostics,
             );
         }
@@ -119,6 +137,7 @@ fn gather_node(
                 interface_level_declaration,
                 symbol_table,
                 fqn_context,
+                scope_ids,
                 diagnostics,
             );
         }
@@ -127,77 +146,139 @@ fn gather_node(
                 class_level_declaration,
                 symbol_table,
                 fqn_context,
+                scope_ids,
                 diagnostics,
             );
         }
         AstNodeRef::Module(module) => {
-            gather_module(module, symbol_table, fqn_context, diagnostics);
+            gather_module(module, symbol_table, fqn_context, scope_ids, diagnostics);
         }
         AstNodeRef::Interface(interface) => {
-            gather_interface(interface, symbol_table, fqn_context, diagnostics);
+            gather_interface(interface, symbol_table, fqn_context, scope_ids, diagnostics);
         }
         AstNodeRef::Class(class) => {
-            gather_class(class, symbol_table, fqn_context, diagnostics);
+            gather_class(class, symbol_table, fqn_context, scope_ids, diagnostics);
         }
         AstNodeRef::Function(function) => {
-            gather_function(function, symbol_table, fqn_context, diagnostics);
+            gather_function(function, symbol_table, fqn_context, scope_ids, diagnostics);
         }
-        AstNodeRef::OperatorFunction(_) => {}
-        AstNodeRef::PlatformFunction(_) => {}
-        AstNodeRef::InterfaceFunction(_) => {}
-        AstNodeRef::InterfaceDefaultFunction(_) => {}
-        AstNodeRef::InterfaceOperatorFunction(_) => {}
-        AstNodeRef::InterfaceDefaultOperatorFunction(_) => {}
-        AstNodeRef::FunctionBody(function_body) => match function_body {
-            FunctionBody::FunctionAliasBody(alias_body) => {
-                gather_node(
-                    alias_body.as_node_ref(),
+        AstNodeRef::OperatorFunction(operator_function) => {
+            gather_operator_function(
+                operator_function,
                 symbol_table,
                 fqn_context,
+                scope_ids,
                 diagnostics,
             );
         }
-            FunctionBody::FunctionEqualsBody(equals_body) => {
-                gather_node(
-                    equals_body.as_node_ref(),
+        AstNodeRef::PlatformFunction(platform_function) => {
+            gather_platform_function(
+                platform_function,
                 symbol_table,
                 fqn_context,
+                scope_ids,
                 diagnostics,
             );
         }
-            FunctionBody::FunctionBlockBody(block_body) => {
-                gather_node(
-                    block_body.as_node_ref(),
+        AstNodeRef::PlatformOperatorFunction(platform_operator_function) => {
+            gather_platform_operator_function(
+                platform_operator_function,
                 symbol_table,
                 fqn_context,
+                scope_ids,
                 diagnostics,
             );
         }
-        },
-        AstNodeRef::FunctionEqualsBody(_) => {}
-        AstNodeRef::FunctionAliasBody(_) => {}
-        AstNodeRef::FunctionBlockBody(block_body) => {
-            gather_function_block_body(block_body, symbol_table, fqn_context, diagnostics);
-        }
-        AstNodeRef::ClassConstructor(_) => {}
-        AstNodeRef::Member(_) => {}
-        AstNodeRef::Statement(statement) => match statement {
-            Statement::VariableDeclaration(variable_declaration) => {
-                gather_node(
-                    variable_declaration.as_node_ref(),
+        AstNodeRef::InterfaceFunction(interface_function) => {
+            gather_interface_function(
+                interface_function,
                 symbol_table,
                 fqn_context,
+                scope_ids,
+                diagnostics,
+            );
+        }
+        AstNodeRef::InterfaceDefaultFunction(interface_default_function) => {
+            gather_interface_default_function(
+                interface_default_function,
+                symbol_table,
+                fqn_context,
+                scope_ids,
+                diagnostics,
+            );
+        }
+        AstNodeRef::InterfaceOperatorFunction(interface_operator_function) => {
+            gather_interface_operator_function(
+                interface_operator_function,
+                symbol_table,
+                fqn_context,
+                scope_ids,
+                diagnostics,
+            );
+        }
+        AstNodeRef::InterfaceDefaultOperatorFunction(interface_default_operator_function) => {
+            gather_interface_default_operator_function(
+                interface_default_operator_function,
+                symbol_table,
+                fqn_context,
+                scope_ids,
+                diagnostics,
+            );
+        }
+        AstNodeRef::FunctionBody(function_body) => {
+            gather_function_body(
+                function_body,
+                symbol_table,
+                fqn_context,
+                scope_ids,
+                diagnostics,
+            );
+        }
+        AstNodeRef::FunctionEqualsBody(function_equals_body) => {
+            gather_node_children(
+                function_equals_body,
+                symbol_table,
+                fqn_context,
+                scope_ids,
+                diagnostics,
+            );
+        }
+        AstNodeRef::FunctionAliasBody(_) => {
+            // no-op
+        }
+        AstNodeRef::FunctionBlockBody(function_block_body) => {
+            gather_node_children(
+                function_block_body,
+                symbol_table,
+                fqn_context,
+                scope_ids,
+                diagnostics,
+            );
+        }
+        AstNodeRef::ClassConstructor(class_constructor) => {
+            gather_node_children(
+                class_constructor,
+                symbol_table,
+                fqn_context,
+                scope_ids,
+                diagnostics,
+            );
+        }
+        AstNodeRef::Member(member) => {
+            gather_member(member, symbol_table, fqn_context, scope_ids, diagnostics);
+        }
+        AstNodeRef::Statement(statement) => {
+            gather_node_children(statement, symbol_table, fqn_context, scope_ids, diagnostics);
+        }
+        AstNodeRef::VariableDeclaration(variable_declaration) => {
+            gather_variable_declaration(
+                variable_declaration,
+                symbol_table,
+                fqn_context,
+                scope_ids,
                 diagnostics,
             );
         }
-            Statement::AssignmentStatement(_) => {}
-            Statement::ExpressionStatement(_) => {}
-            Statement::UseStatement(_) => {}
-            Statement::IfStatement(_) => {}
-            Statement::WhileStatement(_) => {}
-            Statement::ForStatement(_) => {}
-        },
-        AstNodeRef::VariableDeclaration(_) => {}
         AstNodeRef::AssignmentStatement(_) => {}
         AstNodeRef::ExpressionStatement(_) => {}
         AstNodeRef::IfStatement(_) => {}
@@ -206,6 +287,11 @@ fn gather_node(
         AstNodeRef::IfElse(_) => {}
         AstNodeRef::WhileStatement(_) => {}
         AstNodeRef::ForStatement(_) => {}
+        AstNodeRef::LValue(_) => {}
+        AstNodeRef::LValueSuffix(_) => {}
+        AstNodeRef::VariableUse(variable_use) => {
+            gather_variable_use(variable_use, symbol_table, scope_ids);
+        }
         AstNodeRef::Expression(_) => {}
         AstNodeRef::TernaryExpression(_) => {}
         AstNodeRef::TernaryRhs(_) => {}
@@ -251,6 +337,7 @@ pub fn gather_compilation_unit(
     compilation_unit: &mut CompilationUnit,
     file_name: &str,
     symbol_table: &mut SymbolTable,
+    scope_ids: &mut HashMap<VariableUse, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     let mut fqn_context = FqnContext::new();
@@ -259,6 +346,7 @@ pub fn gather_compilation_unit(
         compilation_unit.as_node_ref(),
         symbol_table,
         &mut fqn_context,
+        scope_ids,
         diagnostics,
     );
     symbol_table.pop_scope();
@@ -337,6 +425,7 @@ fn gather_module(
     module: &Module,
     symbol_table: &mut SymbolTable,
     fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     let module_symbol = ModuleSymbol::new(
@@ -364,6 +453,7 @@ fn gather_module(
             declaration.as_node_ref(),
             symbol_table,
             fqn_context,
+            scope_ids,
             diagnostics,
         );
     }
@@ -376,6 +466,7 @@ fn gather_interface(
     interface: &Interface,
     symbol_table: &mut SymbolTable,
     fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     let type_symbol = ConcreteTypeSymbol::new(
@@ -406,6 +497,7 @@ fn gather_interface(
             declaration.as_node_ref(),
             symbol_table,
             fqn_context,
+            scope_ids,
             diagnostics,
         );
     }
@@ -418,6 +510,7 @@ fn gather_class(
     class: &Class,
     symbol_table: &mut SymbolTable,
     fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     let class_symbol = ConcreteTypeSymbol::new(
@@ -443,11 +536,19 @@ fn gather_class(
     fqn_context.push(class.identifier().name());
     symbol_table.push_scope(&format!("ClassScope {}", class.identifier().name()));
 
+    gather_node(
+        class.class_constructor().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
     for declaration in class.class_level_declarations() {
         gather_node(
             declaration.as_node_ref(),
             symbol_table,
             fqn_context,
+            scope_ids,
             diagnostics,
         );
     }
@@ -460,6 +561,7 @@ fn gather_function(
     function: &Function,
     symbol_table: &mut SymbolTable,
     fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     let function_symbol = FunctionSymbol::without_parameters_or_return_type(
@@ -479,29 +581,512 @@ fn gather_function(
             diagnostics,
         );
     }
+    symbol_table.push_scope(&format!("FunctionScope {}", function.identifier().name()));
+    gather_node(
+        function.generics().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        function.parameters().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        function.return_type().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
     gather_node(
         function.function_body().as_node_ref(),
         symbol_table,
         fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    symbol_table.pop_scope();
+}
+
+fn gather_operator_function(
+    operator_function: &OperatorFunction,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let function_symbol = FunctionSymbol::without_parameters_or_return_type(
+        &fqn_context.resolve(&operator_function.operator().inner().name()),
+        operator_function.operator().inner().name(),
+        operator_function.is_public(),
+        false,
+        Some(SourceDefinition::from_operator(
+            operator_function.operator(),
+        )),
+    );
+    if let Err(insert_error) = symbol_table.insert_function_symbol(function_symbol) {
+        handle_insert_error(
+            insert_error,
+            operator_function.operator().inner().name(),
+            operator_function.operator().file_id(),
+            operator_function.operator().range(),
+            "Operator",
             diagnostics,
         );
     }
+    symbol_table.push_scope(&format!(
+        "FunctionScope {}",
+        operator_function.operator().inner().name()
+    ));
+    gather_node(
+        operator_function.generics().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        operator_function.parameters().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        operator_function.return_type().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        operator_function.function_body().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    symbol_table.pop_scope();
+}
 
-fn gather_function_block_body(
-    function_block_body: &FunctionBlockBody,
+fn gather_platform_function(
+    platform_function: &PlatformFunction,
     symbol_table: &mut SymbolTable,
     fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    symbol_table.push_scope("FunctionBlockBody");
-    gather_node_children(function_block_body, symbol_table, fqn_context, diagnostics);
+    let function_symbol = FunctionSymbol::without_parameters_or_return_type(
+        &fqn_context.resolve(platform_function.identifier().name()),
+        platform_function.identifier().name(),
+        platform_function.is_public(),
+        true,
+        Some(SourceDefinition::from_identifier(
+            platform_function.identifier(),
+        )),
+    );
+    if let Err(insert_error) = symbol_table.insert_function_symbol(function_symbol) {
+        handle_insert_error(
+            insert_error,
+            platform_function.identifier().name(),
+            platform_function.identifier().file_id(),
+            platform_function.identifier().range(),
+            "Function",
+            diagnostics,
+        );
+    }
+    symbol_table.push_scope(&format!(
+        "PlatformFunctionScope {}",
+        platform_function.identifier().name()
+    ));
+    gather_node(
+        platform_function.generics().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        platform_function.parameters().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        platform_function.return_type().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
     symbol_table.pop_scope();
 }
 
+fn gather_platform_operator_function(
+    platform_operator_function: &PlatformOperatorFunction,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let function_symbol = FunctionSymbol::without_parameters_or_return_type(
+        &fqn_context.resolve(platform_operator_function.operator().inner().name()),
+        platform_operator_function.operator().inner().name(),
+        platform_operator_function.is_public(),
+        true,
+        Some(SourceDefinition::from_operator(
+            platform_operator_function.operator(),
+        )),
+    );
+    if let Err(insert_error) = symbol_table.insert_function_symbol(function_symbol) {
+        handle_insert_error(
+            insert_error,
+            platform_operator_function.operator().inner().name(),
+            platform_operator_function.operator().file_id(),
+            platform_operator_function.operator().range(),
+            "Function",
+            diagnostics,
+        );
+    }
+    symbol_table.push_scope(&format!(
+        "PlatformOperatorFunctionScope {}",
+        platform_operator_function.operator().inner().name()
+    ));
+    gather_node(
+        platform_operator_function.generics().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        platform_operator_function.parameters().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        platform_operator_function.return_type().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    symbol_table.pop_scope();
+}
+
+fn gather_interface_function(
+    interface_function: &InterfaceFunction,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let function_symbol = FunctionSymbol::without_parameters_or_return_type(
+        &fqn_context.resolve(interface_function.identifier().name()),
+        interface_function.identifier().name(),
+        true,
+        false,
+        Some(SourceDefinition::from_identifier(
+            interface_function.identifier(),
+        )),
+    );
+    if let Err(insert_error) = symbol_table.insert_function_symbol(function_symbol) {
+        handle_insert_error(
+            insert_error,
+            interface_function.identifier().name(),
+            interface_function.identifier().file_id(),
+            interface_function.identifier().range(),
+            "Type",
+            diagnostics,
+        );
+    }
+    symbol_table.push_scope(&format!(
+        "InterfaceFunctionScope {}",
+        interface_function.identifier().name()
+    ));
+    gather_node(
+        interface_function.generics().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_function.parameters().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_function.return_type().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    symbol_table.pop_scope();
+}
+
+fn gather_interface_default_function(
+    interface_default_function: &InterfaceDefaultFunction,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let function_symbol = FunctionSymbol::without_parameters_or_return_type(
+        &fqn_context.resolve(interface_default_function.identifier().name()),
+        interface_default_function.identifier().name(),
+        true,
+        false,
+        Some(SourceDefinition::from_identifier(
+            interface_default_function.identifier(),
+        )),
+    );
+    if let Err(insert_error) = symbol_table.insert_function_symbol(function_symbol) {
+        handle_insert_error(
+            insert_error,
+            interface_default_function.identifier().name(),
+            interface_default_function.identifier().file_id(),
+            interface_default_function.identifier().range(),
+            "Function",
+            diagnostics,
+        );
+    }
+    symbol_table.push_scope(&format!(
+        "InterfaceDefaultFunctionScope {}",
+        interface_default_function.identifier().name()
+    ));
+    gather_node(
+        interface_default_function.generics().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_default_function.parameters().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_default_function.return_type().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_default_function.function_body().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    symbol_table.pop_scope();
+}
+
+fn gather_interface_operator_function(
+    interface_operator_function: &InterfaceOperatorFunction,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let function_symbol = FunctionSymbol::without_parameters_or_return_type(
+        &fqn_context.resolve(interface_operator_function.operator().inner().name()),
+        interface_operator_function.operator().inner().name(),
+        true,
+        false,
+        Some(SourceDefinition::from_operator(
+            interface_operator_function.operator(),
+        )),
+    );
+    if let Err(insert_error) = symbol_table.insert_function_symbol(function_symbol) {
+        handle_insert_error(
+            insert_error,
+            interface_operator_function.operator().inner().name(),
+            interface_operator_function.operator().file_id(),
+            interface_operator_function.operator().range(),
+            "Function",
+            diagnostics,
+        );
+    }
+    symbol_table.push_scope(&format!(
+        "InterfaceOperatorFunctionScope {}",
+        interface_operator_function.operator().inner().name()
+    ));
+    gather_node(
+        interface_operator_function.generics().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_operator_function.parameters().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_operator_function.return_type().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    symbol_table.pop_scope();
+}
+
+fn gather_interface_default_operator_function(
+    interface_default_operator_function: &InterfaceDefaultOperatorFunction,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let function_symbol = FunctionSymbol::without_parameters_or_return_type(
+        &fqn_context.resolve(
+            interface_default_operator_function
+                .operator()
+                .inner()
+                .name(),
+        ),
+        interface_default_operator_function
+            .operator()
+            .inner()
+            .name(),
+        true,
+        false,
+        Some(SourceDefinition::from_operator(
+            interface_default_operator_function.operator(),
+        )),
+    );
+    if let Err(insert_error) = symbol_table.insert_function_symbol(function_symbol) {
+        handle_insert_error(
+            insert_error,
+            interface_default_operator_function
+                .operator()
+                .inner()
+                .name(),
+            interface_default_operator_function.operator().file_id(),
+            interface_default_operator_function.operator().range(),
+            "Function",
+            diagnostics,
+        );
+    }
+    symbol_table.push_scope(&format!(
+        "InterfaceDefaultOperatorFunctionScope {}",
+        interface_default_operator_function
+            .operator()
+            .inner()
+            .name()
+    ));
+    gather_node(
+        interface_default_operator_function.generics().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_default_operator_function
+            .parameters()
+            .as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_default_operator_function
+            .return_type()
+            .as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    gather_node(
+        interface_default_operator_function
+            .function_body()
+            .as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    symbol_table.pop_scope();
+}
+
+fn gather_function_body(
+    function_body: &FunctionBody,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    symbol_table.push_scope("FunctionBodyScope");
+    gather_node_children(
+        function_body,
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+    symbol_table.pop_scope();
+}
+
+fn gather_member(
+    member: &Member,
+    symbol_table: &mut SymbolTable,
+    fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
+    diagnostics: &mut Vec<DmDiagnostic>,
+) {
+    let member_symbol = ClassMemberSymbol::new(
+        member.is_public(),
+        member.is_mut(),
+        member.identifier().name(),
+        Some(SourceDefinition::from_identifier(member.identifier())),
+    );
+    if let Err(insert_error) = symbol_table.insert_class_member_symbol(member_symbol) {
+        handle_insert_error(
+            insert_error,
+            member.identifier().name(),
+            member.identifier().file_id(),
+            member.identifier().range(),
+            "Class Member",
+            diagnostics,
+        );
+    }
+    gather_node(
+        member.type_use().as_node_ref(),
+        symbol_table,
+        fqn_context,
+        scope_ids,
+        diagnostics,
+    );
+}
+
 fn gather_variable_declaration(
     variable_declaration: &VariableDeclaration,
     symbol_table: &mut SymbolTable,
     fqn_context: &mut FqnContext,
+    scope_ids: &mut HashMap<VariableUse, usize>,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     let variable_symbol = VariableSymbol::new(
@@ -526,7 +1111,16 @@ fn gather_variable_declaration(
             expression.as_node_ref(),
             symbol_table,
             fqn_context,
+            scope_ids,
             diagnostics,
         );
     }
 }
+
+fn gather_variable_use(
+    variable_use: &VariableUse,
+    symbol_table: &mut SymbolTable,
+    scope_ids: &mut HashMap<VariableUse, usize>,
+) {
+    scope_ids.insert(variable_use.clone(), symbol_table.current_scope_id());
+}

src/name_analysis/mod.rs

@@ -19,7 +19,7 @@ The resolve phase has one main responsibility: resolve all references based on t
 `scope_id` property.
 */
 
-use crate::ast::node::{CompilationUnit, Identifier};
+use crate::ast::node::{CompilationUnit, VariableUse};
 use crate::diagnostic::DmDiagnostic;
 use crate::name_analysis::gather::gather_compilation_unit;
 // use crate::name_analysis::resolve::resolve_compilation_unit;
@@ -39,12 +39,18 @@ pub fn analyze_names<'a, F: Files<'a, FileId = usize, Name = String>>(
     symbol_table: &mut SymbolTable,
 ) -> Vec<DmDiagnostic> {
     let mut diagnostics = vec![];
-    let mut identifier_scope_ids: HashMap<Identifier, usize> = HashMap::new();
+    let mut scope_ids: HashMap<VariableUse, usize> = HashMap::new();
 
     // gather symbols
     for compilation_unit in compilation_units.iter_mut() {
         let file_name = files.name(compilation_unit.file_id()).unwrap();
-        gather_compilation_unit(compilation_unit, &file_name, symbol_table, &mut diagnostics);
+        gather_compilation_unit(
+            compilation_unit,
+            &file_name,
+            symbol_table,
+            &mut scope_ids,
+            &mut diagnostics,
+        );
     }
 
     // resolve symbols

src/name_analysis/symbol/class_member_symbol.rs

@@ -3,30 +3,37 @@ use std::fmt::{Debug, Formatter};
 
 #[derive(Clone)]
 pub struct ClassMemberSymbol {
+    is_public: bool,
+    is_mut: bool,
     declared_name: String,
-    is_field: bool,
     source_definition: Option<SourceDefinition>,
 }
 
 impl ClassMemberSymbol {
     pub fn new(
+        is_public: bool,
+        is_mut: bool,
         declared_name: &str,
-        is_field: bool,
         source_definition: Option<SourceDefinition>,
     ) -> Self {
         Self {
+            is_public,
+            is_mut,
             declared_name: declared_name.to_string(),
-            is_field,
             source_definition,
         }
     }
     
-    pub fn declared_name(&self) -> &str {
-        &self.declared_name
+    pub fn is_public(&self) -> bool {
+        self.is_public
     }
     
-    pub fn is_field(&self) -> bool {
-        self.is_field
+    pub fn is_mut(&self) -> bool {
+        self.is_mut
+    }
+
+    pub fn declared_name(&self) -> &str {
+        &self.declared_name
     }
 
     pub fn source_definition(&self) -> Option<&SourceDefinition> {
@@ -37,8 +44,9 @@ impl ClassMemberSymbol {
 impl Debug for ClassMemberSymbol {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("ClassMemberSymbol")
+            .field("is_public", &self.is_public)
+            .field("is_mut", &self.is_mut)
             .field("declared_name", &self.declared_name)
-            .field("is_field", &self.is_field)
             .field("source_definition", &self.source_definition)
             .finish()
     }

src/name_analysis/symbol/source_definition.rs

@@ -1,7 +1,7 @@
 use std::cell::RefCell;
 use std::range::Range;
 use std::rc::Rc;
-use crate::ast::node::{Identifier, UseStatement};
+use crate::ast::node::{Identifier, Operator, UseStatement};
 
 #[derive(Clone, Debug)]
 pub struct SourceDefinition {
@@ -17,14 +17,6 @@ impl SourceDefinition {
         }
     }
     
-    pub fn from_identifier_rc(identifier: Rc<RefCell<Identifier>>) -> Self {
-        let borrowed = identifier.borrow();
-        SourceDefinition {
-            file_id: borrowed.file_id(),
-            range: borrowed.range(),
-        }
-    }
-    
     pub fn from_use_statement(use_statement: &UseStatement) -> Self {
         Self {
             file_id: use_statement.file_id(),
@@ -32,6 +24,13 @@ impl SourceDefinition {
         }
     }
     
+    pub fn from_operator(operator: &Operator) -> Self {
+        Self {
+            file_id: operator.file_id(),
+            range: operator.range(),
+        }
+    }
+
     pub fn file_id(&self) -> usize {
         self.file_id
     }

src/name_analysis/symbol_table/mod.rs

@@ -57,11 +57,11 @@ impl SymbolTable {
     }
 
     fn current_scope(&self) -> &Scope {
-        self.scopes.last().unwrap()
+        &self.scopes[self.current_scope_id]
     }
 
     fn current_scope_mut(&mut self) -> &mut Scope {
-        self.scopes.last_mut().unwrap()
+        &mut self.scopes[self.current_scope_id]
     }
 
     fn find_current_scope_concrete_use_symbol(

src/name_analysis/symbol_table/scope.rs

@@ -127,7 +127,13 @@ macro_rules! write_symbols {
 
 impl Display for Scope {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "----Scope {} {}----", self.id(), self.debug_name())?;
+        writeln!(
+            f,
+            "----Scope {} (p: {}) {}----",
+            self.id(),
+            self.parent().map(|parent_id| format!("{}", parent_id)).unwrap_or_else(|| "None".to_string()),
+            self.debug_name()
+        )?;
         write_symbols!(f, self.concrete_use_symbols());
         write_symbols!(f, self.star_use_symbols());
         write_symbols!(f, self.module_symbols());

src/parser/ast.yaml

@@ -1,6 +1,18 @@
 # $schema: ./ast.schema.yaml
 # Operators
 Operator:
+  struct:
+    children:
+      - inner:
+          member:
+            rule: OperatorInner
+      - file_id:
+          special:
+            kind: file_id
+      - range:
+          special:
+            kind: range
+OperatorInner:
   leaf_enum:
     rules:
       - Or
@@ -429,6 +441,30 @@ PlatformFunction:
       - identifier
       - parameters
       - return_type
+PlatformOperatorFunction:
+  struct:
+    children:
+      - is_public:
+          member:
+            rule: Pub
+            build:
+              boolean:
+                on: rule_present
+      - platform_kw:
+          skip:
+            rule: Platform
+      - op_kw:
+          skip:
+            rule: Op
+      - generics:
+          member:
+            rule: GenericParameters
+            build:
+              node:
+                or_else_default: true
+      - operator
+      - parameters
+      - return_type
 InterfaceFunction:
   struct:
     children:
@@ -592,12 +628,8 @@ VariableDeclaration:
 AssignmentStatement:
   struct:
     children:
-      - left:
-          member:
-            rule: Expression
-      - right:
-          member:
-            rule: Expression
+      - l_value
+      - expression
 ExpressionStatement:
   struct:
     children:
@@ -679,6 +711,31 @@ ForStatement:
           skip:
             rule: End
 
+# LValue
+LValue:
+  struct:
+    children:
+      - variable_use
+      - suffixes:
+          vec:
+            rule: LValueSuffix
+LValueSuffix:
+  tree_enum:
+    rules:
+      - ObjectProperty
+      - ObjectIndex
+
+# VariableUse
+VariableUse:
+  struct:
+    children:
+      - identifier
+    derive:
+      - Clone
+      - PartialEq
+      - Eq
+      - Hash
+
 # Expressions
 Expression:
   polymorphic_type:
@@ -713,6 +770,9 @@ Expression:
       - Literal:
           inner:
             kind: Literal
+      - VariableUse:
+          inner:
+            kind: VariableUse
       - Fqn:
           inner:
             kind: FullyQualifiedName
@@ -1055,6 +1115,9 @@ PrimaryExpression:
       - Literal:
           inner:
             kind: Literal
+      - VariableUse:
+          inner:
+            kind: VariableUse
       - Fqn:
           inner:
             kind: FullyQualifiedName

src/parser/deimos.pest

@@ -131,6 +131,10 @@ Index = { "[]" }
 BorrowMut = { Borrow ~ Mut }
 
 Operator = {
+      OperatorInner
+}
+
+OperatorInner = {
       Or
     | And
     | EqualTo
@@ -431,6 +435,16 @@ PlatformFunction = {
     ~ ReturnType
 }
 
+PlatformOperatorFunction = {
+      Pub?
+    ~ Platform
+    ~ Op
+    ~ GenericParameters?
+    ~ Operator
+    ~ Parameters
+    ~ ReturnType
+}
+
 InterfaceFunction = {
       Fn
     ~ GenericParameters?
@@ -528,7 +542,7 @@ VariableDeclaration = {
 }
 
 AssignmentStatement = {
-      Expression
+      LValue
     ~ "="
     ~ Expression
 }
@@ -579,6 +593,24 @@ ForStatement = {
     ~ End
 }
 
+// LValue
+
+LValue = {
+      VariableUse
+    ~ LValueSuffix*
+}
+
+LValueSuffix = {
+      ObjectProperty
+    | ObjectIndex
+}
+
+// Variable Use
+
+VariableUse = {
+      Identifier
+}
+
 // Expressions
 
 Expression = {
@@ -727,6 +759,7 @@ ObjectIndex = {
 
 PrimaryExpression = {
       Literal
+    | VariableUse
     | FullyQualifiedName
     | Closure
     | ListExpression