diff --git a/src/ast/children.rs b/src/ast/children.rs
index 55e3a79..cb815d1 100644
--- a/src/ast/children.rs
+++ b/src/ast/children.rs
@@ -128,7 +128,7 @@ impl HasChildren for GenericParameters {
 
 impl HasChildren for TupleArguments {
     fn children(&self) -> Vec<ChildRef> {
-        self.arguments()
+        self.type_uses()
             .iter()
             .map(|type_use| ChildRef::TypeUse(*type_use))
             .collect()
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index b477d6a..d1ba881 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -367,11 +367,11 @@ impl TupleArguments {
         self.0.is_empty()
     }
 
-    pub fn arguments(&self) -> Vec<&TypeUse> {
+    pub fn type_uses(&self) -> Vec<&TypeUse> {
         self.0.iter().map(Box::as_ref).collect()
     }
 
-    pub fn arguments_mut(&mut self) -> Vec<&mut TypeUse> {
+    pub fn type_uses_mut(&mut self) -> Vec<&mut TypeUse> {
         self.0.iter_mut().map(Box::as_mut).collect()
     }
 }
@@ -674,6 +674,14 @@ impl UseStatement {
     pub fn last_mut(&mut self) -> &mut UseStatementLast {
         &mut self.last
     }
+
+    pub fn file_id(&self) -> usize {
+        self.file_id
+    }
+
+    pub fn range(&self) -> Range<usize> {
+        self.range
+    }
 }
 
 #[derive(Debug)]
@@ -1324,6 +1332,10 @@ impl ClassConstructor {
     pub fn parameters(&self) -> Vec<&ClassConstructorParameter> {
         self.0.iter().map(|p| p.as_ref()).collect()
     }
+    
+    pub fn parameters_mut(&mut self) -> Vec<&mut ClassConstructorParameter> {
+        self.0.iter_mut().map(|p| p.as_mut()).collect()
+    }
 }
 
 #[derive(Debug)]
diff --git a/src/ast/unparse.rs b/src/ast/unparse.rs
index e41738e..44ae4bd 100644
--- a/src/ast/unparse.rs
+++ b/src/ast/unparse.rs
@@ -278,7 +278,7 @@ impl ListUnparse for TupleArguments {
     }
 
     fn inner(&self) -> Vec<&dyn Unparse> {
-        to_unparse_vec!(self.arguments())
+        to_unparse_vec!(self.type_uses())
     }
 }
 
diff --git a/src/name_analysis/gather.rs b/src/name_analysis/gather.rs
index 6c6aa8e..77f6bc7 100644
--- a/src/name_analysis/gather.rs
+++ b/src/name_analysis/gather.rs
@@ -5,7 +5,6 @@ use crate::name_analysis::fqn_context::FqnContext;
 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;
@@ -106,9 +105,9 @@ fn gather_interface_or_class_type_use(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_fully_qualified_name(&mut interface_or_class_type_use.fqn, symbol_table);
+    gather_fully_qualified_name(interface_or_class_type_use.fqn_mut(), symbol_table);
     gather_generic_arguments(
-        &mut interface_or_class_type_use.generics,
+        interface_or_class_type_use.generics_mut(),
         symbol_table,
         fqn_context,
         diagnostics,
@@ -121,7 +120,7 @@ fn gather_tuple_type_use(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for generic_argument in &mut tuple_type_use.arguments.0 {
+    for generic_argument in tuple_type_use.arguments_mut().type_uses_mut() {
         gather_type_use(generic_argument, symbol_table, fqn_context, diagnostics);
     }
 }
@@ -133,15 +132,15 @@ fn gather_function_type_use(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     symbol_table.push_scope("FunctionTypeUseScope");
-    gather_generic_parameters(&mut function_type_use.generics, symbol_table, diagnostics);
+    gather_generic_parameters(function_type_use.generics_mut(), symbol_table, diagnostics);
     gather_parameters(
-        &mut function_type_use.parameters,
+        function_type_use.parameters_mut(),
         symbol_table,
         fqn_context,
         diagnostics,
     );
     gather_return_type(
-        &mut function_type_use.return_type,
+        function_type_use.return_type_mut(),
         symbol_table,
         fqn_context,
         diagnostics,
@@ -157,7 +156,7 @@ fn gather_generic_arguments(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for argument in &mut generic_arguments.0 {
+    for argument in generic_arguments.arguments_mut() {
         gather_type_use(argument, symbol_table, fqn_context, diagnostics);
     }
 }
@@ -169,7 +168,7 @@ fn gather_generic_parameters(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for identifier in &mut generic_parameters.0 {
+    for identifier in generic_parameters.identifiers_mut() {
         let insert_result =
             symbol_table.insert_type_symbol(TypeSymbol::Generic(GenericTypeSymbol::new(
                 &identifier.name(),
@@ -199,7 +198,7 @@ fn gather_implements_list(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for type_use in &mut implements_list.0 {
+    for type_use in implements_list.type_uses_mut() {
         gather_type_use(type_use, symbol_table, fqn_context, diagnostics);
     }
 }
@@ -213,7 +212,7 @@ fn gather_parameters(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) -> Option<Vec<Rc<ParameterSymbol>>> {
     parameters
-        .0
+        .parameters_mut()
         .iter_mut()
         .map(|parameter| gather_parameter(parameter, symbol_table, fqn_context, diagnostics))
         .collect()
@@ -225,21 +224,21 @@ fn gather_parameter(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) -> Option<Rc<ParameterSymbol>> {
-    let parameter_name = parameter.identifier.name();
+    let parameter_name = parameter.identifier().name();
 
     let insert_result = symbol_table.insert_parameter_symbol(ParameterSymbol::new(
         &parameter_name,
-        Some(&parameter.identifier),
+        Some(&parameter.identifier()),
     ));
 
     match insert_result {
         Ok(parameter_symbol) => {
             parameter
-                .identifier
+                .identifier_mut()
                 .set_scope_id(symbol_table.current_scope_id());
 
             gather_type_use(
-                &mut parameter.type_use,
+                parameter.type_use_mut(),
                 symbol_table,
                 fqn_context,
                 diagnostics,
@@ -250,8 +249,8 @@ fn gather_parameter(
             handle_insert_error(
                 err,
                 &parameter_name,
-                parameter.identifier.file_id(),
-                parameter.identifier.range(),
+                parameter.identifier().file_id(),
+                parameter.identifier().range(),
                 "function/variable",
                 diagnostics,
             );
@@ -269,18 +268,18 @@ fn gather_return_type(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     gather_type_use(
-        &mut return_type.declared_type,
+        return_type.declared_type_mut(),
         symbol_table,
         fqn_context,
         diagnostics,
     );
-    gather_references(&mut return_type.references, symbol_table);
+    gather_references(return_type.references_mut(), symbol_table);
 }
 
 /* References */
 
 fn gather_references(references: &mut References, symbol_table: &mut SymbolTable) {
-    for identifier in &mut references.0 {
+    for identifier in references.identifiers_mut() {
         gather_identifier(identifier, symbol_table);
     }
 }
@@ -293,15 +292,15 @@ pub(super) fn gather_compilation_unit(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     let mut fqn_context = FqnContext::new();
-    if let Some(namespace) = &compilation_unit.namespace {
+    if let Some(namespace) = compilation_unit.namespace() {
         fqn_context.push(&namespace.name());
     }
 
-    symbol_table.push_scope(&format!("FileScope({})", compilation_unit.file_name));
-    for use_statement in &mut compilation_unit.use_statements {
+    symbol_table.push_scope(&format!("FileScope({})", compilation_unit.file_name()));
+    for use_statement in compilation_unit.use_statements_mut() {
         gather_use_statement(use_statement, symbol_table, &mut fqn_context, diagnostics)
     }
-    for declaration in &mut compilation_unit.declarations {
+    for declaration in compilation_unit.declarations_mut() {
         gather_module_level_declaration(declaration, symbol_table, &mut fqn_context, diagnostics);
     }
     symbol_table.pop_scope();
@@ -313,34 +312,28 @@ pub(super) fn gather_compilation_unit(
 fn handle_use_statement_import(
     symbol_table: &mut SymbolTable,
     base_name: &str,
-    identifier: Rc<RefCell<Identifier>>,
+    identifier: &mut Identifier,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let borrowed_identifier = identifier.borrow();
-    let declared_name = borrowed_identifier.name().to_string();
+    let declared_name = identifier.name().to_string();
     let insert_result = symbol_table.insert_use_statement_symbol(UseStatementSymbol::new(
         &format!("{}::{}", base_name, &declared_name),
         &declared_name,
-        Some(identifier.clone()),
+        Some(identifier),
     ));
 
     match insert_result {
         Ok(use_statement_symbol) => {
-            drop(borrowed_identifier);
+            gather_identifier(identifier, symbol_table);
 
-            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));
+            identifier.set_saved_symbol(Symbol::UseStatement(use_statement_symbol));
         }
         Err(err) => {
             handle_insert_error(
                 err,
                 &declared_name,
-                borrowed_identifier.file_id(),
-                borrowed_identifier.range(),
+                identifier.file_id(),
+                identifier.range(),
                 "Use statement",
                 diagnostics,
             );
@@ -358,18 +351,13 @@ fn gather_use_statement(
         todo!()
     }
     let base_name = use_statement.base_name().to_string();
-    match &mut use_statement.last {
+    match use_statement.last_mut() {
         UseStatementLast::Identifier(identifier) => {
-            handle_use_statement_import(symbol_table, &base_name, identifier.clone(), diagnostics)
+            handle_use_statement_import(symbol_table, &base_name, identifier, diagnostics)
         }
         UseStatementLast::Identifiers(identifiers) => {
             for identifier in identifiers {
-                handle_use_statement_import(
-                    symbol_table,
-                    &base_name,
-                    identifier.clone(),
-                    diagnostics,
-                )
+                handle_use_statement_import(symbol_table, &base_name, identifier, diagnostics)
             }
         }
         UseStatementLast::Star => panic!(),
@@ -525,13 +513,13 @@ fn gather_module_declaration(
     // 5. Pop scope
     // 6. Pop fqn_context
 
-    let module_name = declaration.identifier.name();
+    let module_name = declaration.identifier().name();
 
     let insert_result = symbol_table.insert_module_symbol(ModuleSymbol::new(
         &fqn_context.resolve(&module_name),
         &module_name,
-        declaration.is_public,
-        Some(&declaration.identifier),
+        declaration.is_public(),
+        Some(declaration.identifier()),
     ));
 
     match insert_result {
@@ -539,7 +527,7 @@ fn gather_module_declaration(
             fqn_context.push(&module_name);
             symbol_table.push_scope(&format!("ModuleScope({})", module_name));
 
-            for inner_declaration in &mut declaration.declarations {
+            for inner_declaration in declaration.declarations_mut() {
                 gather_module_level_declaration(
                     inner_declaration,
                     symbol_table,
@@ -554,8 +542,8 @@ fn gather_module_declaration(
         Err(insert_error) => handle_insert_error(
             insert_error,
             &module_name,
-            declaration.identifier.file_id(),
-            declaration.identifier.range(),
+            declaration.identifier().file_id(),
+            declaration.identifier().range(),
             "Module",
             diagnostics,
         ),
@@ -568,14 +556,14 @@ fn gather_interface_declaration(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let interface_name = declaration.identifier.name();
+    let interface_name = declaration.identifier().name();
 
     let insert_result =
         symbol_table.insert_type_symbol(TypeSymbol::Concrete(ConcreteTypeSymbol::new(
             &fqn_context.resolve(&interface_name),
             &interface_name,
-            declaration.is_public,
-            Some(&declaration.identifier),
+            declaration.is_public(),
+            Some(declaration.identifier()),
         )));
 
     match insert_result {
@@ -583,7 +571,7 @@ fn gather_interface_declaration(
             fqn_context.push(&interface_name);
             symbol_table.push_scope(&format!("InterfaceScope({})", interface_name));
 
-            for inner_declaration in &mut declaration.declarations {
+            for inner_declaration in declaration.declarations_mut() {
                 gather_interface_level_declaration(
                     inner_declaration,
                     symbol_table,
@@ -599,8 +587,8 @@ fn gather_interface_declaration(
             handle_insert_error(
                 insert_error,
                 &interface_name,
-                declaration.identifier.file_id(),
-                declaration.identifier.range(),
+                declaration.identifier().file_id(),
+                declaration.identifier().range(),
                 "Interface",
                 diagnostics,
             );
@@ -614,21 +602,21 @@ fn gather_class_declaration(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let class_name = class_declaration.identifier.name();
+    let class_name = class_declaration.identifier().name().to_string();
 
     let insert_result =
         symbol_table.insert_type_symbol(TypeSymbol::Concrete(ConcreteTypeSymbol::new(
             &fqn_context.resolve(&class_name),
             &class_name,
-            class_declaration.is_public,
-            Some(&class_declaration.identifier),
+            class_declaration.is_public(),
+            Some(class_declaration.identifier()),
         )));
 
     match insert_result {
         Ok(_) => {
             // Do this first so we can't implement generic parameters!
             gather_implements_list(
-                &mut class_declaration.implements,
+                class_declaration.implements_mut(),
                 symbol_table,
                 fqn_context,
                 diagnostics,
@@ -637,13 +625,13 @@ fn gather_class_declaration(
             fqn_context.push(&class_name);
             symbol_table.push_scope(&format!("ClassScope({})", class_name));
 
-            gather_generic_parameters(&mut class_declaration.generics, symbol_table, diagnostics);
+            gather_generic_parameters(class_declaration.generics_mut(), symbol_table, diagnostics);
 
-            if let Some(class_constructor) = &mut class_declaration.class_constructor {
+            if let Some(class_constructor) = class_declaration.class_constructor_mut() {
                 gather_class_constructor(class_constructor, symbol_table, fqn_context, diagnostics);
             }
 
-            for inner_declaration in &mut class_declaration.declarations {
+            for inner_declaration in class_declaration.declarations_mut() {
                 gather_class_level_declaration(
                     inner_declaration,
                     symbol_table,
@@ -659,8 +647,8 @@ fn gather_class_declaration(
             handle_insert_error(
                 insert_error,
                 &class_name,
-                class_declaration.identifier.file_id(),
-                class_declaration.identifier.range(),
+                class_declaration.identifier().file_id(),
+                class_declaration.identifier().range(),
                 "interface/class",
                 diagnostics,
             );
@@ -676,27 +664,27 @@ fn gather_function_definition(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let declared_name = function.identifier.name();
+    let declared_name = function.identifier().name();
     let resolved_name = fqn_context.resolve(&declared_name);
 
     let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new(
         &resolved_name,
         &declared_name,
-        function.is_public,
+        function.is_public(),
         false,
-        Some(&function.identifier),
+        Some(function.identifier()),
     ));
 
     match insert_result {
         Ok(function_symbol) => {
             function
-                .identifier
+                .identifier_mut()
                 .set_scope_id(symbol_table.current_scope_id());
 
             symbol_table.push_scope(&format!("FunctionParameterScope({})", resolved_name));
 
             let parameters_result = gather_parameters(
-                &mut function.parameters,
+                function.parameters_mut(),
                 symbol_table,
                 fqn_context,
                 diagnostics,
@@ -712,7 +700,7 @@ fn gather_function_definition(
             }
 
             gather_return_type(
-                &mut function.return_type,
+                function.return_type_mut(),
                 symbol_table,
                 fqn_context,
                 diagnostics,
@@ -720,7 +708,7 @@ fn gather_function_definition(
 
             symbol_table.push_scope(&format!("FunctionBodyScope({})", resolved_name));
 
-            gather_function_body(&mut function.body, symbol_table, fqn_context, diagnostics);
+            gather_function_body(function.body_mut(), symbol_table, fqn_context, diagnostics);
 
             symbol_table.pop_scope(); // body
             symbol_table.pop_scope(); // parameters
@@ -729,8 +717,8 @@ fn gather_function_definition(
             handle_insert_error(
                 err,
                 &declared_name,
-                function.identifier.file_id(),
-                function.identifier.range(),
+                function.identifier().file_id(),
+                function.identifier().range(),
                 "function/variable",
                 diagnostics,
             );
@@ -753,24 +741,26 @@ fn gather_platform_function_definition(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let declared_name = platform_function_declaration.identifier.name();
+    let declared_name = platform_function_declaration.identifier().name();
     let fully_qualified_name = fqn_context.resolve(&declared_name);
 
     let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new(
         &fully_qualified_name,
         &declared_name,
-        platform_function_declaration.is_public,
+        platform_function_declaration.is_public(),
         true,
-        Some(&platform_function_declaration.identifier),
+        Some(platform_function_declaration.identifier()),
     ));
 
     match insert_result {
         Ok(function_symbol) => {
-            let declared_name_as_string =
-                platform_function_declaration.identifier.name().to_string();
+            let declared_name_as_string = platform_function_declaration
+                .identifier()
+                .name()
+                .to_string();
 
             platform_function_declaration
-                .identifier
+                .identifier_mut()
                 .set_scope_id(symbol_table.current_scope_id());
 
             symbol_table.push_scope(&format!(
@@ -779,7 +769,7 @@ fn gather_platform_function_definition(
             ));
 
             let parameter_symbols_result = gather_parameters(
-                &mut platform_function_declaration.parameters,
+                platform_function_declaration.parameters_mut(),
                 symbol_table,
                 fqn_context,
                 diagnostics,
@@ -795,7 +785,7 @@ fn gather_platform_function_definition(
             }
 
             gather_return_type(
-                &mut platform_function_declaration.return_type,
+                platform_function_declaration.return_type_mut(),
                 symbol_table,
                 fqn_context,
                 diagnostics,
@@ -807,8 +797,8 @@ fn gather_platform_function_definition(
             handle_insert_error(
                 err,
                 &declared_name,
-                platform_function_declaration.identifier.file_id(),
-                platform_function_declaration.identifier.range(),
+                platform_function_declaration.identifier().file_id(),
+                platform_function_declaration.identifier().range(),
                 "(Platform-) Function",
                 diagnostics,
             );
@@ -822,23 +812,23 @@ fn gather_interface_function_declaration(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let name = declaration.identifier.name();
+    let name = declaration.identifier().name();
     let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new(
         &fqn_context.resolve(&name),
         &name,
         true,
         false,
-        Some(&declaration.identifier),
+        Some(declaration.identifier()),
     ));
 
     match insert_result {
         Ok(function_symbol) => {
             symbol_table.push_scope(&format!("FunctionParameterScope({})", &name));
 
-            gather_generic_parameters(&mut declaration.generics, symbol_table, diagnostics);
+            gather_generic_parameters(declaration.generics_mut(), symbol_table, diagnostics);
 
             let parameters = gather_parameters(
-                &mut declaration.parameters,
+                declaration.parameters_mut(),
                 symbol_table,
                 fqn_context,
                 diagnostics,
@@ -850,13 +840,13 @@ fn gather_interface_function_declaration(
             }
 
             gather_return_type(
-                &mut declaration.return_type,
+                declaration.return_type_mut(),
                 symbol_table,
                 fqn_context,
                 diagnostics,
             );
 
-            if let Some(body) = &mut declaration.body {
+            if let Some(body) = declaration.body_mut() {
                 gather_function_body(body, symbol_table, fqn_context, diagnostics);
             }
 
@@ -866,8 +856,8 @@ fn gather_interface_function_declaration(
             handle_insert_error(
                 insert_error,
                 &name,
-                declaration.identifier.file_id(),
-                declaration.identifier.range(),
+                declaration.identifier().file_id(),
+                declaration.identifier().range(),
                 "Interface Function",
                 diagnostics,
             );
@@ -906,13 +896,18 @@ fn gather_class_constructor(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for parameter in &mut class_constructor.0 {
+    for parameter in class_constructor.parameters_mut() {
         match parameter {
             ClassConstructorParameter::Property(property) => {
-                gather_property_declaration(property, symbol_table, fqn_context, diagnostics);
+                gather_property_declaration(
+                    property.deref_mut(),
+                    symbol_table,
+                    fqn_context,
+                    diagnostics,
+                );
             }
             ClassConstructorParameter::Field(field) => {
-                gather_field_declaration(field, symbol_table, fqn_context, diagnostics);
+                gather_field_declaration(field.deref_mut(), symbol_table, fqn_context, diagnostics);
             }
         }
     }
@@ -924,19 +919,18 @@ fn gather_property_declaration(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let insert_result = symbol_table.insert_class_member_symbol(
-        ClassMemberSymbol::new(
-            &property_declaration.identifier.name(),
-            false,
-            Some(SourceDefinition::from_identifier(&property_declaration.identifier))
-        )
-    );
+    let identifier = property_declaration.identifier();
+    let insert_result = symbol_table.insert_class_member_symbol(ClassMemberSymbol::new(
+        &identifier.name(),
+        false,
+        Some(SourceDefinition::from_identifier(identifier)),
+    ));
     if let Err(insert_error) = insert_result {
         handle_insert_error(
             insert_error,
-            &property_declaration.identifier.name(),
-            property_declaration.identifier.file_id(),
-            property_declaration.identifier.range(),
+            &identifier.name(),
+            identifier.file_id(),
+            identifier.range(),
             "Data Member",
             diagnostics,
         );
@@ -949,19 +943,18 @@ fn gather_field_declaration(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let insert_result = symbol_table.insert_class_member_symbol(
-        ClassMemberSymbol::new(
-            &field_declaration.identifier.name(),
-            true,
-            Some(SourceDefinition::from_identifier(&field_declaration.identifier))
-        )
-    );
+    let identifier = field_declaration.identifier();
+    let insert_result = symbol_table.insert_class_member_symbol(ClassMemberSymbol::new(
+        &identifier.name(),
+        true,
+        Some(SourceDefinition::from_identifier(identifier)),
+    ));
     if let Err(insert_error) = insert_result {
         handle_insert_error(
             insert_error,
-            &field_declaration.identifier.name(),
-            field_declaration.identifier.file_id(),
-            field_declaration.identifier.range(),
+            &identifier.name(),
+            identifier.file_id(),
+            identifier.range(),
             "Data Member",
             diagnostics,
         );
@@ -987,10 +980,10 @@ fn gather_block_statement_inner(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for statement in &mut block.statements {
+    for statement in block.statements_mut() {
         gather_statement(statement, symbol_table, fqn_context, diagnostics);
     }
-    if let Some(expression) = &mut block.expression {
+    if let Some(expression) = block.expression_mut() {
         gather_expression(expression, symbol_table, diagnostics);
     }
 }
@@ -1024,30 +1017,31 @@ fn gather_variable_declaration(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    let variable_name = variable_declaration.identifier.name();
+    let identifier = variable_declaration.identifier();
+    let variable_name = identifier.name();
 
     let insert_result = symbol_table.insert_variable_symbol(VariableSymbol::new(
         &variable_name,
-        variable_declaration.is_mutable,
-        Some(&variable_declaration.identifier),
+        variable_declaration.is_mutable(),
+        Some(identifier),
     ));
 
     if let Err(err) = insert_result {
         handle_insert_error(
             err,
             &variable_name,
-            variable_declaration.identifier.file_id(),
-            variable_declaration.identifier.range(),
+            identifier.file_id(),
+            identifier.range(),
             "function/variable",
             diagnostics,
         )
     }
 
     variable_declaration
-        .identifier
+        .identifier_mut()
         .set_scope_id(symbol_table.current_scope_id());
 
-    if let Some(initializer) = &mut variable_declaration.initializer {
+    if let Some(initializer) = variable_declaration.initializer_mut() {
         gather_expression(initializer, symbol_table, diagnostics);
     }
 }
@@ -1058,8 +1052,8 @@ fn gather_assign_statement(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut assign_statement.lhs, symbol_table, diagnostics);
-    gather_expression(&mut assign_statement.rhs, symbol_table, diagnostics);
+    gather_expression(assign_statement.lhs_mut(), symbol_table, diagnostics);
+    gather_expression(assign_statement.rhs_mut(), symbol_table, diagnostics);
 }
 
 fn gather_call_statement(
@@ -1067,16 +1061,15 @@ fn gather_call_statement(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut call_statement.0, symbol_table, diagnostics);
+    gather_expression(call_statement.expression_mut(), 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 {
+    if let Some(expression) = return_statement.expression_mut() {
         gather_expression(expression, symbol_table, diagnostics);
     }
 }
@@ -1087,9 +1080,9 @@ fn gather_if_statement(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut if_statement.condition, symbol_table, diagnostics);
+    gather_expression(if_statement.condition_mut(), symbol_table, diagnostics);
     gather_block_statement(
-        &mut if_statement.then_block,
+        if_statement.then_block_mut(),
         symbol_table,
         fqn_context,
         diagnostics,
@@ -1103,16 +1096,21 @@ fn gather_if_else_statement(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     gather_if_statement(
-        &mut if_else_statement.if_statement,
+        if_else_statement.if_statement_mut(),
         symbol_table,
         fqn_context,
         diagnostics,
     );
-    for if_statement in &mut if_else_statement.else_ifs.0 {
+    for if_statement in if_else_statement.else_ifs_mut().if_statements_mut() {
         gather_if_statement(if_statement, symbol_table, fqn_context, diagnostics);
     }
-    if let Some(else_block) = &mut if_else_statement.else_block {
-        gather_block_statement(&mut else_block.0, symbol_table, fqn_context, diagnostics);
+    if let Some(else_block) = if_else_statement.else_block_mut() {
+        gather_block_statement(
+            else_block.block_statement_mut(),
+            symbol_table,
+            fqn_context,
+            diagnostics,
+        );
     }
 }
 
@@ -1122,9 +1120,9 @@ fn gather_while_statement(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut while_statement.condition, symbol_table, diagnostics);
+    gather_expression(while_statement.condition_mut(), symbol_table, diagnostics);
     gather_block_statement(
-        &mut while_statement.body,
+        while_statement.body_mut(),
         symbol_table,
         fqn_context,
         diagnostics,
@@ -1137,9 +1135,9 @@ fn gather_for_statement(
     fqn_context: &mut FqnContext,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut for_statement.iterator, symbol_table, diagnostics);
+    gather_expression(for_statement.iterator_mut(), symbol_table, diagnostics);
     symbol_table.push_scope("ForStatementScope");
-    let variable_identifier = &mut for_statement.variable;
+    let variable_identifier = for_statement.variable_mut();
     let insert_result = symbol_table.insert_variable_symbol(VariableSymbol::new(
         &variable_identifier.name(),
         false,
@@ -1149,7 +1147,7 @@ fn gather_for_statement(
     match insert_result {
         Ok(_) => {
             gather_block_statement_inner(
-                &mut for_statement.body,
+                for_statement.body_mut(),
                 symbol_table,
                 fqn_context,
                 diagnostics,
@@ -1214,14 +1212,18 @@ fn gather_ternary_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut ternary_expression.condition, symbol_table, diagnostics);
     gather_expression(
-        &mut ternary_expression.true_expression,
+        ternary_expression.condition_mut(),
         symbol_table,
         diagnostics,
     );
     gather_expression(
-        &mut ternary_expression.false_expression,
+        ternary_expression.true_expression_mut(),
+        symbol_table,
+        diagnostics,
+    );
+    gather_expression(
+        ternary_expression.false_expression_mut(),
         symbol_table,
         diagnostics,
     );
@@ -1232,8 +1234,8 @@ fn gather_binary_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut binary_expression.left, symbol_table, diagnostics);
-    gather_expression(&mut binary_expression.right, symbol_table, diagnostics);
+    gather_expression(binary_expression.left_mut(), symbol_table, diagnostics);
+    gather_expression(binary_expression.right_mut(), symbol_table, diagnostics);
 }
 
 fn gather_prefix_expression(
@@ -1241,7 +1243,11 @@ fn gather_prefix_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut prefix_expression.expression, symbol_table, diagnostics);
+    gather_expression(
+        prefix_expression.expression_mut(),
+        symbol_table,
+        diagnostics,
+    );
 }
 
 fn gather_suffix_expression(
@@ -1249,7 +1255,11 @@ fn gather_suffix_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut suffix_expression.expression, symbol_table, diagnostics);
+    gather_expression(
+        suffix_expression.expression_mut(),
+        symbol_table,
+        diagnostics,
+    );
 }
 
 fn gather_call_expression(
@@ -1257,12 +1267,12 @@ fn gather_call_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut call_expression.callee, symbol_table, diagnostics);
-    if let Some(turbo_fish) = &mut call_expression.turbo_fish {
+    gather_expression(call_expression.callee_mut(), symbol_table, diagnostics);
+    if let Some(turbo_fish) = call_expression.turbo_fish_mut() {
         gather_turbo_fish(turbo_fish, symbol_table, diagnostics);
     }
-    for call_argument in &mut call_expression.arguments.0 {
-        gather_expression(&mut call_argument.0, symbol_table, diagnostics);
+    for call_argument in call_expression.arguments_mut().arguments_mut() {
+        gather_expression(call_argument.expression_mut(), symbol_table, diagnostics);
     }
 }
 
@@ -1287,8 +1297,8 @@ fn gather_object_access(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    gather_expression(&mut object_access.receiver, symbol_table, diagnostics);
-    for object_navigation in &mut object_access.navigations.0 {
+    gather_expression(object_access.receiver_mut(), symbol_table, diagnostics);
+    for object_navigation in object_access.navigations_mut().navigations_mut() {
         match object_navigation {
             ObjectNavigation::Index(index_expression) => {
                 gather_expression(index_expression, symbol_table, diagnostics);
diff --git a/src/name_analysis/resolve.rs b/src/name_analysis/resolve.rs
index 2a59831..4cd672d 100644
--- a/src/name_analysis/resolve.rs
+++ b/src/name_analysis/resolve.rs
@@ -4,9 +4,8 @@ use crate::diagnostic::DmDiagnostic;
 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::ops::DerefMut;
 use std::range::Range;
-use std::rc::Rc;
 
 /* Type Use */
 
@@ -56,7 +55,7 @@ fn resolve_interface_or_class_type_use(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     // 1. handle main name
-    let fqn = &mut interface_or_class_type_use.fqn;
+    let fqn = interface_or_class_type_use.fqn_mut();
     let lookup_result = if fqn.is_single_identifier() {
         let identifier = fqn.last();
         symbol_table.lookup_type_by_declared_name(
@@ -86,7 +85,7 @@ fn resolve_interface_or_class_type_use(
 
     // 2. generics
     resolve_generic_arguments(
-        &mut interface_or_class_type_use.generics,
+        interface_or_class_type_use.generics_mut(),
         symbol_table,
         diagnostics,
     );
@@ -97,7 +96,7 @@ fn resolve_tuple_type_use(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_tuple_arguments(&mut tuple_type_use.arguments, symbol_table, diagnostics);
+    resolve_tuple_arguments(tuple_type_use.arguments_mut(), symbol_table, diagnostics);
 }
 
 fn resolve_function_type_use(
@@ -105,9 +104,13 @@ fn resolve_function_type_use(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_parameters(&mut function_type_use.parameters, symbol_table, diagnostics);
+    resolve_parameters(
+        function_type_use.parameters_mut(),
+        symbol_table,
+        diagnostics,
+    );
     resolve_return_type(
-        &mut function_type_use.return_type,
+        function_type_use.return_type_mut(),
         symbol_table,
         diagnostics,
     );
@@ -120,7 +123,7 @@ fn resolve_generic_arguments(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for generic_argument in &mut generic_arguments.0 {
+    for generic_argument in generic_arguments.arguments_mut() {
         resolve_type_use(generic_argument, symbol_table, diagnostics);
     }
 }
@@ -134,7 +137,7 @@ fn resolve_tuple_arguments(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for type_use in &mut tuple_type_use.0 {
+    for type_use in tuple_type_use.type_uses_mut() {
         resolve_type_use(type_use, symbol_table, diagnostics);
     }
 }
@@ -146,7 +149,7 @@ fn resolve_implements_list(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for type_use in &mut implements_list.0 {
+    for type_use in implements_list.type_uses_mut() {
         resolve_type_use(type_use, symbol_table, diagnostics);
     }
 }
@@ -158,8 +161,8 @@ fn resolve_parameters(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for parameter in &mut parameters.0 {
-        resolve_type_use(&mut parameter.type_use, symbol_table, diagnostics);
+    for parameter in parameters.parameters_mut() {
+        resolve_type_use(parameter.type_use_mut(), symbol_table, diagnostics);
     }
 }
 
@@ -170,8 +173,8 @@ fn resolve_return_type(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_type_use(&mut return_type.declared_type, symbol_table, diagnostics);
-    resolve_references(&mut return_type.references, symbol_table, diagnostics);
+    resolve_type_use(return_type.declared_type_mut(), symbol_table, diagnostics);
+    resolve_references(return_type.references_mut(), symbol_table, diagnostics);
 }
 
 /* References */
@@ -181,7 +184,7 @@ fn resolve_references(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for reference in &mut references.0 {
+    for reference in references.identifiers_mut() {
         todo!()
     }
 }
@@ -193,10 +196,10 @@ pub(super) fn resolve_compilation_unit(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for use_statement in &mut compilation_unit.use_statements {
+    for use_statement in compilation_unit.use_statements_mut() {
         resolve_use_statement(use_statement, symbol_table, diagnostics);
     }
-    for declaration in &mut compilation_unit.declarations {
+    for declaration in compilation_unit.declarations_mut() {
         resolve_module_level_declaration(declaration, symbol_table, diagnostics);
     }
 }
@@ -204,22 +207,20 @@ pub(super) fn resolve_compilation_unit(
 /* Use Statement */
 
 fn handle_use_statement_identifier(
-    identifier: Rc<RefCell<Identifier>>,
+    identifier: &mut 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 declared_name = 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());
+    let lookup_result = symbol_table.lookup_usable_by_fqn(&fqn, identifier.scope_id().unwrap());
 
     match lookup_result {
         Ok(referenced_symbol) => {
-            let saved_symbol = borrowed_identifier
+            let saved_symbol = identifier
                 .saved_symbol()
                 .expect("Identifier's saved_symbol is not set.");
             let use_statement_symbol = saved_symbol.unwrap_use_statement_symbol();
@@ -242,28 +243,31 @@ fn resolve_use_statement(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
+    let file_id = use_statement.file_id();
+    let use_statement_range = use_statement.range();
     let base_name = use_statement.base_name().to_string();
 
-    match &use_statement.last {
+    match use_statement.last_mut() {
         UseStatementLast::Identifier(identifier) => {
             handle_use_statement_identifier(
-                identifier.clone(),
+                identifier.deref_mut(),
                 &base_name,
                 symbol_table,
                 diagnostics,
-                use_statement.file_id,
-                use_statement.range,
+                file_id,
+                use_statement_range,
             );
         }
         UseStatementLast::Identifiers(identifiers) => {
             for identifier in identifiers {
+                let identifier_range = identifier.range();
                 handle_use_statement_identifier(
-                    identifier.clone(),
+                    identifier.deref_mut(),
                     &base_name,
                     symbol_table,
                     diagnostics,
-                    use_statement.file_id,
-                    identifier.borrow().range(),
+                    file_id,
+                    identifier_range,
                 )
             }
         }
@@ -382,7 +386,7 @@ fn resolve_module_declaration(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for declaration in &mut module_declaration.declarations {
+    for declaration in module_declaration.declarations_mut() {
         resolve_module_level_declaration(declaration, symbol_table, diagnostics);
     }
 }
@@ -393,11 +397,11 @@ fn resolve_interface_declaration(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     resolve_implements_list(
-        &mut interface_declaration.implements,
+        interface_declaration.implements_mut(),
         symbol_table,
         diagnostics,
     );
-    for declaration in &mut interface_declaration.declarations {
+    for declaration in interface_declaration.declarations_mut() {
         resolve_interface_level_declaration(declaration, symbol_table, diagnostics);
     }
 }
@@ -407,11 +411,11 @@ fn resolve_class_declaration(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    if let Some(class_constructor) = &mut class_declaration.class_constructor {
+    if let Some(class_constructor) = class_declaration.class_constructor_mut() {
         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_implements_list(class_declaration.implements_mut(), symbol_table, diagnostics);
+    for declaration in class_declaration.declarations_mut() {
         resolve_class_level_declaration(declaration, symbol_table, diagnostics);
     }
 }
@@ -424,16 +428,16 @@ fn resolve_function_definition(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     resolve_parameters(
-        &mut function_definition.parameters,
+        function_definition.parameters_mut(),
         symbol_table,
         diagnostics,
     );
     resolve_return_type(
-        &mut function_definition.return_type,
+        function_definition.return_type_mut(),
         symbol_table,
         diagnostics,
     );
-    resolve_function_body(&mut function_definition.body, symbol_table, diagnostics);
+    resolve_function_body(function_definition.body_mut(), symbol_table, diagnostics);
 }
 
 fn resolve_operator_function_definition(
@@ -450,12 +454,12 @@ fn resolve_platform_function_declaration(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     resolve_parameters(
-        &mut platform_function_declaration.parameters,
+        platform_function_declaration.parameters_mut(),
         symbol_table,
         diagnostics,
     );
     resolve_return_type(
-        &mut platform_function_declaration.return_type,
+        platform_function_declaration.return_type_mut(),
         symbol_table,
         diagnostics,
     );
@@ -467,16 +471,16 @@ fn resolve_interface_function_declaration(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     resolve_parameters(
-        &mut interface_function_declaration.parameters,
+        interface_function_declaration.parameters_mut(),
         symbol_table,
         diagnostics,
     );
     resolve_return_type(
-        &mut interface_function_declaration.return_type,
+        interface_function_declaration.return_type_mut(),
         symbol_table,
         diagnostics,
     );
-    if let Some(body) = &mut interface_function_declaration.body {
+    if let Some(body) = interface_function_declaration.body_mut() {
         resolve_function_body(body, symbol_table, diagnostics);
     }
 }
@@ -518,7 +522,7 @@ fn resolve_class_constructor(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     use crate::ast::ClassConstructorParameter::*;
-    for parameter in &mut class_constructor.0 {
+    for parameter in class_constructor.parameters_mut() {
         match parameter {
             Property(property) => resolve_property_declaration(property, symbol_table, diagnostics),
             Field(field) => resolve_field_declaration(field, symbol_table, diagnostics),
@@ -532,7 +536,7 @@ fn resolve_property_declaration(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     resolve_type_use(
-        &mut property_declaration.declared_type,
+        property_declaration.declared_type_mut(),
         symbol_table,
         diagnostics,
     );
@@ -544,7 +548,7 @@ fn resolve_field_declaration(
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
     resolve_type_use(
-        &mut field_declaration.declared_type,
+        field_declaration.declared_type_mut(),
         symbol_table,
         diagnostics,
     );
@@ -557,10 +561,10 @@ fn resolve_block_statement(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for statement in block_statement.statements.iter_mut() {
+    for statement in block_statement.statements_mut() {
         resolve_statement(statement, symbol_table, diagnostics);
     }
-    if let Some(expression) = block_statement.expression.as_mut() {
+    if let Some(expression) = block_statement.expression_mut() {
         resolve_expression(expression, symbol_table, diagnostics);
     }
 }
@@ -591,7 +595,7 @@ fn resolve_variable_declaration(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    if let Some(initializer) = &mut variable_declaration.initializer {
+    if let Some(initializer) = variable_declaration.initializer_mut() {
         resolve_expression(initializer, symbol_table, diagnostics)
     }
 }
@@ -601,8 +605,8 @@ fn resolve_assign_statement(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_expression(&mut assign_statement.lhs, symbol_table, diagnostics);
-    resolve_expression(&mut assign_statement.rhs, symbol_table, diagnostics);
+    resolve_expression(assign_statement.lhs_mut(), symbol_table, diagnostics);
+    resolve_expression(assign_statement.rhs_mut(), symbol_table, diagnostics);
 }
 
 fn resolve_call_statement(
@@ -610,7 +614,7 @@ fn resolve_call_statement(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_expression(&mut call_statement.0, symbol_table, diagnostics)
+    resolve_expression(call_statement.expression_mut(), symbol_table, diagnostics)
 }
 
 fn resolve_return_statement(
@@ -618,7 +622,7 @@ fn resolve_return_statement(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    if let Some(expression) = &mut return_statement.0 {
+    if let Some(expression) = return_statement.expression_mut() {
         resolve_expression(expression, symbol_table, diagnostics);
     }
 }
@@ -737,14 +741,14 @@ fn resolve_ternary_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_expression(&mut ternary_expression.condition, symbol_table, diagnostics);
+    resolve_expression(ternary_expression.condition_mut(), symbol_table, diagnostics);
     resolve_expression(
-        &mut ternary_expression.true_expression,
+        ternary_expression.true_expression_mut(),
         symbol_table,
         diagnostics,
     );
     resolve_expression(
-        &mut ternary_expression.false_expression,
+        ternary_expression.false_expression_mut(),
         symbol_table,
         diagnostics,
     );
@@ -755,8 +759,8 @@ fn resolve_binary_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_expression(&mut binary_expression.left, symbol_table, diagnostics);
-    resolve_expression(&mut binary_expression.right, symbol_table, diagnostics);
+    resolve_expression(binary_expression.left_mut(), symbol_table, diagnostics);
+    resolve_expression(binary_expression.right_mut(), symbol_table, diagnostics);
 }
 
 fn resolve_prefix_expression(
@@ -764,7 +768,7 @@ fn resolve_prefix_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_expression(&mut prefix_expression.expression, symbol_table, diagnostics);
+    resolve_expression(prefix_expression.expression_mut(), symbol_table, diagnostics);
 }
 
 fn resolve_suffix_expression(
@@ -772,7 +776,7 @@ fn resolve_suffix_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_expression(&mut suffix_expression.expression, symbol_table, diagnostics);
+    resolve_expression(suffix_expression.expression_mut(), symbol_table, diagnostics);
 }
 
 fn resolve_call_expression(
@@ -780,11 +784,11 @@ fn resolve_call_expression(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_expression(&mut call_expression.callee, symbol_table, diagnostics);
-    if let Some(turbo_fish) = &mut call_expression.turbo_fish {
+    resolve_expression(call_expression.callee_mut(), symbol_table, diagnostics);
+    if let Some(turbo_fish) = call_expression.turbo_fish_mut() {
         resolve_turbo_fish(turbo_fish, symbol_table, diagnostics);
     }
-    resolve_call_arguments(&mut call_expression.arguments, symbol_table, diagnostics);
+    resolve_call_arguments(call_expression.arguments_mut(), symbol_table, diagnostics);
 }
 
 fn resolve_turbo_fish(
@@ -792,7 +796,7 @@ fn resolve_turbo_fish(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_generic_arguments(&mut turbo_fish.0, symbol_table, diagnostics);
+    resolve_generic_arguments(turbo_fish.generics_mut(), symbol_table, diagnostics);
 }
 
 fn resolve_call_arguments(
@@ -800,7 +804,7 @@ fn resolve_call_arguments(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    for argument in &mut call_arguments.0 {
+    for argument in call_arguments.arguments_mut() {
         resolve_call_argument(argument, symbol_table, diagnostics);
     }
 }
@@ -810,7 +814,7 @@ fn resolve_call_argument(
     symbol_table: &mut SymbolTable,
     diagnostics: &mut Vec<DmDiagnostic>,
 ) {
-    resolve_expression(&mut call_argument.0, symbol_table, diagnostics);
+    resolve_expression(call_argument.expression_mut(), symbol_table, diagnostics);
 }
 
 fn resolve_closure(
diff --git a/src/name_analysis/symbol.rs b/src/name_analysis/symbol.rs
index fbc4bc6..d877cad 100644
--- a/src/name_analysis/symbol.rs
+++ b/src/name_analysis/symbol.rs
@@ -31,8 +31,8 @@ impl SourceDefinition {
     #[deprecated(note = "Use identifier instead.")]
     pub fn from_use_statement(use_statement: &UseStatement) -> Self {
         SourceDefinition {
-            file_id: use_statement.file_id,
-            range: use_statement.range,
+            file_id: use_statement.file_id(),
+            range: use_statement.range(),
         }
     }
 
@@ -100,12 +100,12 @@ impl UseStatementSymbol {
     pub fn new(
         fqn: &str,
         declared_name: &str,
-        identifier: Option<Rc<RefCell<Identifier>>>,
+        identifier: Option<&Identifier>,
     ) -> Self {
         UseStatementSymbol {
             fqn: fqn.to_string(),
             declared_name: declared_name.to_string(),
-            definition: identifier.map(SourceDefinition::from_identifier_rc),
+            definition: identifier.map(SourceDefinition::from_identifier),
             referenced_symbol: None,
         }
     }