jessebrault/deimos-lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor name-analysis module to use new AST api.

Browse Source
This commit is contained in:
Jesse Brault 2025-05-26 07:48:35 -05:00
parent 20dcb4f6ce
commit cbf7921c95
6 changed files with 255 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/ast/children.rs
View File

@ -128,7 +128,7 @@ impl HasChildren for GenericParameters {
impl HasChildren for TupleArguments { impl HasChildren for TupleArguments {
fn children(&self) -> Vec<ChildRef> { fn children(&self) -> Vec<ChildRef> {
self.arguments() self.type_uses()
.iter() .iter()
.map(|type_use| ChildRef::TypeUse(*type_use)) .map(|type_use| ChildRef::TypeUse(*type_use))
.collect() .collect()

16
src/ast/mod.rs
View File

@ -367,11 +367,11 @@ impl TupleArguments {
self.0.is_empty() 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() 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() self.0.iter_mut().map(Box::as_mut).collect()
} }
} }
@ -674,6 +674,14 @@ impl UseStatement {
pub fn last_mut(&mut self) -> &mut UseStatementLast { pub fn last_mut(&mut self) -> &mut UseStatementLast {
&mut self.last &mut self.last
} }
pub fn file_id(&self) -> usize {
self.file_id
}
pub fn range(&self) -> Range<usize> {
self.range
}
} }
#[derive(Debug)] #[derive(Debug)]
@ -1324,6 +1332,10 @@ impl ClassConstructor {
pub fn parameters(&self) -> Vec<&ClassConstructorParameter> { pub fn parameters(&self) -> Vec<&ClassConstructorParameter> {
self.0.iter().map(|p| p.as_ref()).collect() 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)] #[derive(Debug)]

2
src/ast/unparse.rs
View File

@ -278,7 +278,7 @@ impl ListUnparse for TupleArguments {
} }
fn inner(&self) -> Vec<&dyn Unparse> { fn inner(&self) -> Vec<&dyn Unparse> {
to_unparse_vec!(self.arguments()) to_unparse_vec!(self.type_uses())
} }
} }

318
src/name_analysis/gather.rs
View File

@ -5,7 +5,6 @@ use crate::name_analysis::fqn_context::FqnContext;
use crate::name_analysis::symbol::*; use crate::name_analysis::symbol::*;
use crate::name_analysis::symbol_table::{SymbolInsertError, SymbolTable}; use crate::name_analysis::symbol_table::{SymbolInsertError, SymbolTable};
use codespan_reporting::diagnostic::{Diagnostic, Label}; use codespan_reporting::diagnostic::{Diagnostic, Label};
use std::cell::RefCell;
use std::ops::DerefMut; use std::ops::DerefMut;
use std::range::Range; use std::range::Range;
use std::rc::Rc; use std::rc::Rc;
@ -106,9 +105,9 @@ fn gather_interface_or_class_type_use(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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( gather_generic_arguments(
&mut interface_or_class_type_use.generics, interface_or_class_type_use.generics_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -121,7 +120,7 @@ fn gather_tuple_type_use(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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); gather_type_use(generic_argument, symbol_table, fqn_context, diagnostics);
} }
} }
@ -133,15 +132,15 @@ fn gather_function_type_use(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
symbol_table.push_scope("FunctionTypeUseScope"); 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( gather_parameters(
&mut function_type_use.parameters, function_type_use.parameters_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
); );
gather_return_type( gather_return_type(
&mut function_type_use.return_type, function_type_use.return_type_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -157,7 +156,7 @@ fn gather_generic_arguments(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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); gather_type_use(argument, symbol_table, fqn_context, diagnostics);
} }
} }
@ -169,7 +168,7 @@ fn gather_generic_parameters(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
for identifier in &mut generic_parameters.0 { for identifier in generic_parameters.identifiers_mut() {
let insert_result = let insert_result =
symbol_table.insert_type_symbol(TypeSymbol::Generic(GenericTypeSymbol::new( symbol_table.insert_type_symbol(TypeSymbol::Generic(GenericTypeSymbol::new(
&identifier.name(), &identifier.name(),
@ -199,7 +198,7 @@ fn gather_implements_list(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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); gather_type_use(type_use, symbol_table, fqn_context, diagnostics);
} }
} }
@ -213,7 +212,7 @@ fn gather_parameters(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) -> Option<Vec<Rc<ParameterSymbol>>> { ) -> Option<Vec<Rc<ParameterSymbol>>> {
parameters parameters
.0 .parameters_mut()
.iter_mut() .iter_mut()
.map(|parameter| gather_parameter(parameter, symbol_table, fqn_context, diagnostics)) .map(|parameter| gather_parameter(parameter, symbol_table, fqn_context, diagnostics))
.collect() .collect()
@ -225,21 +224,21 @@ fn gather_parameter(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) -> Option<Rc<ParameterSymbol>> { ) -> 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( let insert_result = symbol_table.insert_parameter_symbol(ParameterSymbol::new(
&parameter_name, &parameter_name,
Some(&parameter.identifier), Some(&parameter.identifier()),
)); ));
match insert_result { match insert_result {
Ok(parameter_symbol) => { Ok(parameter_symbol) => {
parameter parameter
.identifier .identifier_mut()
.set_scope_id(symbol_table.current_scope_id()); .set_scope_id(symbol_table.current_scope_id());
gather_type_use( gather_type_use(
&mut parameter.type_use, parameter.type_use_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -250,8 +249,8 @@ fn gather_parameter(
handle_insert_error( handle_insert_error(
err, err,
&parameter_name, &parameter_name,
parameter.identifier.file_id(), parameter.identifier().file_id(),
parameter.identifier.range(), parameter.identifier().range(),
"function/variable", "function/variable",
diagnostics, diagnostics,
); );
@ -269,18 +268,18 @@ fn gather_return_type(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
gather_type_use( gather_type_use(
&mut return_type.declared_type, return_type.declared_type_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
); );
gather_references(&mut return_type.references, symbol_table); gather_references(return_type.references_mut(), symbol_table);
} }
/* References */ /* References */
fn gather_references(references: &mut References, symbol_table: &mut SymbolTable) { 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); gather_identifier(identifier, symbol_table);
} }
} }
@ -293,15 +292,15 @@ pub(super) fn gather_compilation_unit(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
let mut fqn_context = FqnContext::new(); 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()); fqn_context.push(&namespace.name());
} }
symbol_table.push_scope(&format!("FileScope({})", compilation_unit.file_name)); symbol_table.push_scope(&format!("FileScope({})", compilation_unit.file_name()));
for use_statement in &mut compilation_unit.use_statements { for use_statement in compilation_unit.use_statements_mut() {
gather_use_statement(use_statement, symbol_table, &mut fqn_context, diagnostics) 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); gather_module_level_declaration(declaration, symbol_table, &mut fqn_context, diagnostics);
} }
symbol_table.pop_scope(); symbol_table.pop_scope();
@ -313,34 +312,28 @@ pub(super) fn gather_compilation_unit(
fn handle_use_statement_import( fn handle_use_statement_import(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
base_name: &str, base_name: &str,
identifier: Rc<RefCell<Identifier>>, identifier: &mut Identifier,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
let borrowed_identifier = identifier.borrow(); let declared_name = identifier.name().to_string();
let declared_name = borrowed_identifier.name().to_string();
let insert_result = symbol_table.insert_use_statement_symbol(UseStatementSymbol::new( let insert_result = symbol_table.insert_use_statement_symbol(UseStatementSymbol::new(
&format!("{}::{}", base_name, &declared_name), &format!("{}::{}", base_name, &declared_name),
&declared_name, &declared_name,
Some(identifier.clone()), Some(identifier),
)); ));
match insert_result { match insert_result {
Ok(use_statement_symbol) => { Ok(use_statement_symbol) => {
drop(borrowed_identifier); gather_identifier(identifier, symbol_table);
let mut mutable_borrowed_identifier = identifier.borrow_mut(); identifier.set_saved_symbol(Symbol::UseStatement(use_statement_symbol));
gather_identifier(mutable_borrowed_identifier.deref_mut(), symbol_table);
mutable_borrowed_identifier
.set_saved_symbol(Symbol::UseStatement(use_statement_symbol));
} }
Err(err) => { Err(err) => {
handle_insert_error( handle_insert_error(
err, err,
&declared_name, &declared_name,
borrowed_identifier.file_id(), identifier.file_id(),
borrowed_identifier.range(), identifier.range(),
"Use statement", "Use statement",
diagnostics, diagnostics,
); );
@ -358,18 +351,13 @@ fn gather_use_statement(
todo!() todo!()
} }
let base_name = use_statement.base_name().to_string(); let base_name = use_statement.base_name().to_string();
match &mut use_statement.last { match use_statement.last_mut() {
UseStatementLast::Identifier(identifier) => { 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) => { UseStatementLast::Identifiers(identifiers) => {
for identifier in identifiers { for identifier in identifiers {
handle_use_statement_import( handle_use_statement_import(symbol_table, &base_name, identifier, diagnostics)
symbol_table,
&base_name,
identifier.clone(),
diagnostics,
)
} }
} }
UseStatementLast::Star => panic!(), UseStatementLast::Star => panic!(),
@ -525,13 +513,13 @@ fn gather_module_declaration(
// 5. Pop scope // 5. Pop scope
// 6. Pop fqn_context // 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( let insert_result = symbol_table.insert_module_symbol(ModuleSymbol::new(
&fqn_context.resolve(&module_name), &fqn_context.resolve(&module_name),
&module_name, &module_name,
declaration.is_public, declaration.is_public(),
Some(&declaration.identifier), Some(declaration.identifier()),
)); ));
match insert_result { match insert_result {
@ -539,7 +527,7 @@ fn gather_module_declaration(
fqn_context.push(&module_name); fqn_context.push(&module_name);
symbol_table.push_scope(&format!("ModuleScope({})", 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( gather_module_level_declaration(
inner_declaration, inner_declaration,
symbol_table, symbol_table,
@ -554,8 +542,8 @@ fn gather_module_declaration(
Err(insert_error) => handle_insert_error( Err(insert_error) => handle_insert_error(
insert_error, insert_error,
&module_name, &module_name,
declaration.identifier.file_id(), declaration.identifier().file_id(),
declaration.identifier.range(), declaration.identifier().range(),
"Module", "Module",
diagnostics, diagnostics,
), ),
@ -568,14 +556,14 @@ fn gather_interface_declaration(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
let interface_name = declaration.identifier.name(); let interface_name = declaration.identifier().name();
let insert_result = let insert_result =
symbol_table.insert_type_symbol(TypeSymbol::Concrete(ConcreteTypeSymbol::new( symbol_table.insert_type_symbol(TypeSymbol::Concrete(ConcreteTypeSymbol::new(
&fqn_context.resolve(&interface_name), &fqn_context.resolve(&interface_name),
&interface_name, &interface_name,
declaration.is_public, declaration.is_public(),
Some(&declaration.identifier), Some(declaration.identifier()),
))); )));
match insert_result { match insert_result {
@ -583,7 +571,7 @@ fn gather_interface_declaration(
fqn_context.push(&interface_name); fqn_context.push(&interface_name);
symbol_table.push_scope(&format!("InterfaceScope({})", 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( gather_interface_level_declaration(
inner_declaration, inner_declaration,
symbol_table, symbol_table,
@ -599,8 +587,8 @@ fn gather_interface_declaration(
handle_insert_error( handle_insert_error(
insert_error, insert_error,
&interface_name, &interface_name,
declaration.identifier.file_id(), declaration.identifier().file_id(),
declaration.identifier.range(), declaration.identifier().range(),
"Interface", "Interface",
diagnostics, diagnostics,
); );
@ -614,21 +602,21 @@ fn gather_class_declaration(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
let class_name = class_declaration.identifier.name(); let class_name = class_declaration.identifier().name().to_string();
let insert_result = let insert_result =
symbol_table.insert_type_symbol(TypeSymbol::Concrete(ConcreteTypeSymbol::new( symbol_table.insert_type_symbol(TypeSymbol::Concrete(ConcreteTypeSymbol::new(
&fqn_context.resolve(&class_name), &fqn_context.resolve(&class_name),
&class_name, &class_name,
class_declaration.is_public, class_declaration.is_public(),
Some(&class_declaration.identifier), Some(class_declaration.identifier()),
))); )));
match insert_result { match insert_result {
Ok(_) => { Ok(_) => {
// Do this first so we can't implement generic parameters! // Do this first so we can't implement generic parameters!
gather_implements_list( gather_implements_list(
&mut class_declaration.implements, class_declaration.implements_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -637,13 +625,13 @@ fn gather_class_declaration(
fqn_context.push(&class_name); fqn_context.push(&class_name);
symbol_table.push_scope(&format!("ClassScope({})", 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); 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( gather_class_level_declaration(
inner_declaration, inner_declaration,
symbol_table, symbol_table,
@ -659,8 +647,8 @@ fn gather_class_declaration(
handle_insert_error( handle_insert_error(
insert_error, insert_error,
&class_name, &class_name,
class_declaration.identifier.file_id(), class_declaration.identifier().file_id(),
class_declaration.identifier.range(), class_declaration.identifier().range(),
"interface/class", "interface/class",
diagnostics, diagnostics,
); );
@ -676,27 +664,27 @@ fn gather_function_definition(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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 resolved_name = fqn_context.resolve(&declared_name);
let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new( let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new(
&resolved_name, &resolved_name,
&declared_name, &declared_name,
function.is_public, function.is_public(),
false, false,
Some(&function.identifier), Some(function.identifier()),
)); ));
match insert_result { match insert_result {
Ok(function_symbol) => { Ok(function_symbol) => {
function function
.identifier .identifier_mut()
.set_scope_id(symbol_table.current_scope_id()); .set_scope_id(symbol_table.current_scope_id());
symbol_table.push_scope(&format!("FunctionParameterScope({})", resolved_name)); symbol_table.push_scope(&format!("FunctionParameterScope({})", resolved_name));
let parameters_result = gather_parameters( let parameters_result = gather_parameters(
&mut function.parameters, function.parameters_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -712,7 +700,7 @@ fn gather_function_definition(
} }
gather_return_type( gather_return_type(
&mut function.return_type, function.return_type_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -720,7 +708,7 @@ fn gather_function_definition(
symbol_table.push_scope(&format!("FunctionBodyScope({})", resolved_name)); 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(); // body
symbol_table.pop_scope(); // parameters symbol_table.pop_scope(); // parameters
@ -729,8 +717,8 @@ fn gather_function_definition(
handle_insert_error( handle_insert_error(
err, err,
&declared_name, &declared_name,
function.identifier.file_id(), function.identifier().file_id(),
function.identifier.range(), function.identifier().range(),
"function/variable", "function/variable",
diagnostics, diagnostics,
); );
@ -753,24 +741,26 @@ fn gather_platform_function_definition(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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 fully_qualified_name = fqn_context.resolve(&declared_name);
let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new( let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new(
&fully_qualified_name, &fully_qualified_name,
&declared_name, &declared_name,
platform_function_declaration.is_public, platform_function_declaration.is_public(),
true, true,
Some(&platform_function_declaration.identifier), Some(platform_function_declaration.identifier()),
)); ));
match insert_result { match insert_result {
Ok(function_symbol) => { Ok(function_symbol) => {
let declared_name_as_string = let declared_name_as_string = platform_function_declaration
platform_function_declaration.identifier.name().to_string(); .identifier()
.name()
.to_string();
platform_function_declaration platform_function_declaration
.identifier .identifier_mut()
.set_scope_id(symbol_table.current_scope_id()); .set_scope_id(symbol_table.current_scope_id());
symbol_table.push_scope(&format!( symbol_table.push_scope(&format!(
@ -779,7 +769,7 @@ fn gather_platform_function_definition(
)); ));
let parameter_symbols_result = gather_parameters( let parameter_symbols_result = gather_parameters(
&mut platform_function_declaration.parameters, platform_function_declaration.parameters_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -795,7 +785,7 @@ fn gather_platform_function_definition(
} }
gather_return_type( gather_return_type(
&mut platform_function_declaration.return_type, platform_function_declaration.return_type_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -807,8 +797,8 @@ fn gather_platform_function_definition(
handle_insert_error( handle_insert_error(
err, err,
&declared_name, &declared_name,
platform_function_declaration.identifier.file_id(), platform_function_declaration.identifier().file_id(),
platform_function_declaration.identifier.range(), platform_function_declaration.identifier().range(),
"(Platform-) Function", "(Platform-) Function",
diagnostics, diagnostics,
); );
@ -822,23 +812,23 @@ fn gather_interface_function_declaration(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
let name = declaration.identifier.name(); let name = declaration.identifier().name();
let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new( let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new(
&fqn_context.resolve(&name), &fqn_context.resolve(&name),
&name, &name,
true, true,
false, false,
Some(&declaration.identifier), Some(declaration.identifier()),
)); ));
match insert_result { match insert_result {
Ok(function_symbol) => { Ok(function_symbol) => {
symbol_table.push_scope(&format!("FunctionParameterScope({})", &name)); 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( let parameters = gather_parameters(
&mut declaration.parameters, declaration.parameters_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -850,13 +840,13 @@ fn gather_interface_function_declaration(
} }
gather_return_type( gather_return_type(
&mut declaration.return_type, declaration.return_type_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
); );
if let Some(body) = &mut declaration.body { if let Some(body) = declaration.body_mut() {
gather_function_body(body, symbol_table, fqn_context, diagnostics); gather_function_body(body, symbol_table, fqn_context, diagnostics);
} }
@ -866,8 +856,8 @@ fn gather_interface_function_declaration(
handle_insert_error( handle_insert_error(
insert_error, insert_error,
&name, &name,
declaration.identifier.file_id(), declaration.identifier().file_id(),
declaration.identifier.range(), declaration.identifier().range(),
"Interface Function", "Interface Function",
diagnostics, diagnostics,
); );
@ -906,13 +896,18 @@ fn gather_class_constructor(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
for parameter in &mut class_constructor.0 { for parameter in class_constructor.parameters_mut() {
match parameter { match parameter {
ClassConstructorParameter::Property(property) => { 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) => { 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, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
let insert_result = symbol_table.insert_class_member_symbol( let identifier = property_declaration.identifier();
ClassMemberSymbol::new( let insert_result = symbol_table.insert_class_member_symbol(ClassMemberSymbol::new(
&property_declaration.identifier.name(), &identifier.name(),
false, false,
Some(SourceDefinition::from_identifier(&property_declaration.identifier)) Some(SourceDefinition::from_identifier(identifier)),
) ));
);
if let Err(insert_error) = insert_result { if let Err(insert_error) = insert_result {
handle_insert_error( handle_insert_error(
insert_error, insert_error,
&property_declaration.identifier.name(), &identifier.name(),
property_declaration.identifier.file_id(), identifier.file_id(),
property_declaration.identifier.range(), identifier.range(),
"Data Member", "Data Member",
diagnostics, diagnostics,
); );
@ -949,19 +943,18 @@ fn gather_field_declaration(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
let insert_result = symbol_table.insert_class_member_symbol( let identifier = field_declaration.identifier();
ClassMemberSymbol::new( let insert_result = symbol_table.insert_class_member_symbol(ClassMemberSymbol::new(
&field_declaration.identifier.name(), &identifier.name(),
true, true,
Some(SourceDefinition::from_identifier(&field_declaration.identifier)) Some(SourceDefinition::from_identifier(identifier)),
) ));
);
if let Err(insert_error) = insert_result { if let Err(insert_error) = insert_result {
handle_insert_error( handle_insert_error(
insert_error, insert_error,
&field_declaration.identifier.name(), &identifier.name(),
field_declaration.identifier.file_id(), identifier.file_id(),
field_declaration.identifier.range(), identifier.range(),
"Data Member", "Data Member",
diagnostics, diagnostics,
); );
@ -987,10 +980,10 @@ fn gather_block_statement_inner(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
for statement in &mut block.statements { for statement in block.statements_mut() {
gather_statement(statement, symbol_table, fqn_context, diagnostics); 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); gather_expression(expression, symbol_table, diagnostics);
} }
} }
@ -1024,30 +1017,31 @@ fn gather_variable_declaration(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( let insert_result = symbol_table.insert_variable_symbol(VariableSymbol::new(
&variable_name, &variable_name,
variable_declaration.is_mutable, variable_declaration.is_mutable(),
Some(&variable_declaration.identifier), Some(identifier),
)); ));
if let Err(err) = insert_result { if let Err(err) = insert_result {
handle_insert_error( handle_insert_error(
err, err,
&variable_name, &variable_name,
variable_declaration.identifier.file_id(), identifier.file_id(),
variable_declaration.identifier.range(), identifier.range(),
"function/variable", "function/variable",
diagnostics, diagnostics,
) )
} }
variable_declaration variable_declaration
.identifier .identifier_mut()
.set_scope_id(symbol_table.current_scope_id()); .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); gather_expression(initializer, symbol_table, diagnostics);
} }
} }
@ -1058,8 +1052,8 @@ fn gather_assign_statement(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
gather_expression(&mut assign_statement.lhs, symbol_table, diagnostics); gather_expression(assign_statement.lhs_mut(), symbol_table, diagnostics);
gather_expression(&mut assign_statement.rhs, symbol_table, diagnostics); gather_expression(assign_statement.rhs_mut(), symbol_table, diagnostics);
} }
fn gather_call_statement( fn gather_call_statement(
@ -1067,16 +1061,15 @@ fn gather_call_statement(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( fn gather_return_statement(
return_statement: &mut ReturnStatement, return_statement: &mut ReturnStatement,
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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); gather_expression(expression, symbol_table, diagnostics);
} }
} }
@ -1087,9 +1080,9 @@ fn gather_if_statement(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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( gather_block_statement(
&mut if_statement.then_block, if_statement.then_block_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -1103,16 +1096,21 @@ fn gather_if_else_statement(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
gather_if_statement( gather_if_statement(
&mut if_else_statement.if_statement, if_else_statement.if_statement_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, 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); gather_if_statement(if_statement, symbol_table, fqn_context, diagnostics);
} }
if let Some(else_block) = &mut if_else_statement.else_block { if let Some(else_block) = if_else_statement.else_block_mut() {
gather_block_statement(&mut else_block.0, symbol_table, fqn_context, diagnostics); 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, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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( gather_block_statement(
&mut while_statement.body, while_statement.body_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -1137,9 +1135,9 @@ fn gather_for_statement(
fqn_context: &mut FqnContext, fqn_context: &mut FqnContext,
diagnostics: &mut Vec<DmDiagnostic>, 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"); 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( let insert_result = symbol_table.insert_variable_symbol(VariableSymbol::new(
&variable_identifier.name(), &variable_identifier.name(),
false, false,
@ -1149,7 +1147,7 @@ fn gather_for_statement(
match insert_result { match insert_result {
Ok(_) => { Ok(_) => {
gather_block_statement_inner( gather_block_statement_inner(
&mut for_statement.body, for_statement.body_mut(),
symbol_table, symbol_table,
fqn_context, fqn_context,
diagnostics, diagnostics,
@ -1214,14 +1212,18 @@ fn gather_ternary_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
gather_expression(&mut ternary_expression.condition, symbol_table, diagnostics);
gather_expression( gather_expression(
&mut ternary_expression.true_expression, ternary_expression.condition_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
gather_expression( gather_expression(
&mut ternary_expression.false_expression, ternary_expression.true_expression_mut(),
symbol_table,
diagnostics,
);
gather_expression(
ternary_expression.false_expression_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
@ -1232,8 +1234,8 @@ fn gather_binary_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
gather_expression(&mut binary_expression.left, symbol_table, diagnostics); gather_expression(binary_expression.left_mut(), symbol_table, diagnostics);
gather_expression(&mut binary_expression.right, symbol_table, diagnostics); gather_expression(binary_expression.right_mut(), symbol_table, diagnostics);
} }
fn gather_prefix_expression( fn gather_prefix_expression(
@ -1241,7 +1243,11 @@ fn gather_prefix_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( fn gather_suffix_expression(
@ -1249,7 +1255,11 @@ fn gather_suffix_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( fn gather_call_expression(
@ -1257,12 +1267,12 @@ fn gather_call_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
gather_expression(&mut call_expression.callee, symbol_table, diagnostics); gather_expression(call_expression.callee_mut(), symbol_table, diagnostics);
if let Some(turbo_fish) = &mut call_expression.turbo_fish { if let Some(turbo_fish) = call_expression.turbo_fish_mut() {
gather_turbo_fish(turbo_fish, symbol_table, diagnostics); gather_turbo_fish(turbo_fish, symbol_table, diagnostics);
} }
for call_argument in &mut call_expression.arguments.0 { for call_argument in call_expression.arguments_mut().arguments_mut() {
gather_expression(&mut call_argument.0, symbol_table, diagnostics); gather_expression(call_argument.expression_mut(), symbol_table, diagnostics);
} }
} }
@ -1287,8 +1297,8 @@ fn gather_object_access(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
gather_expression(&mut object_access.receiver, symbol_table, diagnostics); gather_expression(object_access.receiver_mut(), symbol_table, diagnostics);
for object_navigation in &mut object_access.navigations.0 { for object_navigation in object_access.navigations_mut().navigations_mut() {
match object_navigation { match object_navigation {
ObjectNavigation::Index(index_expression) => { ObjectNavigation::Index(index_expression) => {
gather_expression(index_expression, symbol_table, diagnostics); gather_expression(index_expression, symbol_table, diagnostics);

138
src/name_analysis/resolve.rs
View File

@ -4,9 +4,8 @@ use crate::diagnostic::DmDiagnostic;
use crate::name_analysis::symbol::Symbol; use crate::name_analysis::symbol::Symbol;
use crate::name_analysis::symbol_table::{SymbolLookupError, SymbolTable}; use crate::name_analysis::symbol_table::{SymbolLookupError, SymbolTable};
use codespan_reporting::diagnostic::{Diagnostic, Label}; use codespan_reporting::diagnostic::{Diagnostic, Label};
use std::cell::RefCell; use std::ops::DerefMut;
use std::range::Range; use std::range::Range;
use std::rc::Rc;
/* Type Use */ /* Type Use */
@ -56,7 +55,7 @@ fn resolve_interface_or_class_type_use(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
// 1. handle main name // 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 lookup_result = if fqn.is_single_identifier() {
let identifier = fqn.last(); let identifier = fqn.last();
symbol_table.lookup_type_by_declared_name( symbol_table.lookup_type_by_declared_name(
@ -86,7 +85,7 @@ fn resolve_interface_or_class_type_use(
// 2. generics // 2. generics
resolve_generic_arguments( resolve_generic_arguments(
&mut interface_or_class_type_use.generics, interface_or_class_type_use.generics_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
@ -97,7 +96,7 @@ fn resolve_tuple_type_use(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( fn resolve_function_type_use(
@ -105,9 +104,13 @@ fn resolve_function_type_use(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( resolve_return_type(
&mut function_type_use.return_type, function_type_use.return_type_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
@ -120,7 +123,7 @@ fn resolve_generic_arguments(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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); resolve_type_use(generic_argument, symbol_table, diagnostics);
} }
} }
@ -134,7 +137,7 @@ fn resolve_tuple_arguments(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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); resolve_type_use(type_use, symbol_table, diagnostics);
} }
} }
@ -146,7 +149,7 @@ fn resolve_implements_list(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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); resolve_type_use(type_use, symbol_table, diagnostics);
} }
} }
@ -158,8 +161,8 @@ fn resolve_parameters(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
for parameter in &mut parameters.0 { for parameter in parameters.parameters_mut() {
resolve_type_use(&mut parameter.type_use, symbol_table, diagnostics); resolve_type_use(parameter.type_use_mut(), symbol_table, diagnostics);
} }
} }
@ -170,8 +173,8 @@ fn resolve_return_type(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_type_use(&mut return_type.declared_type, symbol_table, diagnostics); resolve_type_use(return_type.declared_type_mut(), symbol_table, diagnostics);
resolve_references(&mut return_type.references, symbol_table, diagnostics); resolve_references(return_type.references_mut(), symbol_table, diagnostics);
} }
/* References */ /* References */
@ -181,7 +184,7 @@ fn resolve_references(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
for reference in &mut references.0 { for reference in references.identifiers_mut() {
todo!() todo!()
} }
} }
@ -193,10 +196,10 @@ pub(super) fn resolve_compilation_unit(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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); 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); resolve_module_level_declaration(declaration, symbol_table, diagnostics);
} }
} }
@ -204,22 +207,20 @@ pub(super) fn resolve_compilation_unit(
/* Use Statement */ /* Use Statement */
fn handle_use_statement_identifier( fn handle_use_statement_identifier(
identifier: Rc<RefCell<Identifier>>, identifier: &mut Identifier,
base_name: &str, base_name: &str,
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
file_id: usize, file_id: usize,
error_range: Range<usize>, error_range: Range<usize>,
) { ) {
let borrowed_identifier = identifier.borrow(); let declared_name = identifier.name().to_string();
let declared_name = borrowed_identifier.name().to_string();
let fqn = format!("{}::{}", base_name, &declared_name); let fqn = format!("{}::{}", base_name, &declared_name);
let lookup_result = let lookup_result = symbol_table.lookup_usable_by_fqn(&fqn, identifier.scope_id().unwrap());
symbol_table.lookup_usable_by_fqn(&fqn, borrowed_identifier.scope_id().unwrap());
match lookup_result { match lookup_result {
Ok(referenced_symbol) => { Ok(referenced_symbol) => {
let saved_symbol = borrowed_identifier let saved_symbol = identifier
.saved_symbol() .saved_symbol()
.expect("Identifier's saved_symbol is not set."); .expect("Identifier's saved_symbol is not set.");
let use_statement_symbol = saved_symbol.unwrap_use_statement_symbol(); let use_statement_symbol = saved_symbol.unwrap_use_statement_symbol();
@ -242,28 +243,31 @@ fn resolve_use_statement(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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(); let base_name = use_statement.base_name().to_string();
match &use_statement.last { match use_statement.last_mut() {
UseStatementLast::Identifier(identifier) => { UseStatementLast::Identifier(identifier) => {
handle_use_statement_identifier( handle_use_statement_identifier(
identifier.clone(), identifier.deref_mut(),
&base_name, &base_name,
symbol_table, symbol_table,
diagnostics, diagnostics,
use_statement.file_id, file_id,
use_statement.range, use_statement_range,
); );
} }
UseStatementLast::Identifiers(identifiers) => { UseStatementLast::Identifiers(identifiers) => {
for identifier in identifiers { for identifier in identifiers {
let identifier_range = identifier.range();
handle_use_statement_identifier( handle_use_statement_identifier(
identifier.clone(), identifier.deref_mut(),
&base_name, &base_name,
symbol_table, symbol_table,
diagnostics, diagnostics,
use_statement.file_id, file_id,
identifier.borrow().range(), identifier_range,
) )
} }
} }
@ -382,7 +386,7 @@ fn resolve_module_declaration(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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); resolve_module_level_declaration(declaration, symbol_table, diagnostics);
} }
} }
@ -393,11 +397,11 @@ fn resolve_interface_declaration(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_implements_list( resolve_implements_list(
&mut interface_declaration.implements, interface_declaration.implements_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
for declaration in &mut interface_declaration.declarations { for declaration in interface_declaration.declarations_mut() {
resolve_interface_level_declaration(declaration, symbol_table, diagnostics); resolve_interface_level_declaration(declaration, symbol_table, diagnostics);
} }
} }
@ -407,11 +411,11 @@ fn resolve_class_declaration(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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_class_constructor(class_constructor, symbol_table, diagnostics);
} }
resolve_implements_list(&mut class_declaration.implements, symbol_table, diagnostics); resolve_implements_list(class_declaration.implements_mut(), symbol_table, diagnostics);
for declaration in &mut class_declaration.declarations { for declaration in class_declaration.declarations_mut() {
resolve_class_level_declaration(declaration, symbol_table, diagnostics); resolve_class_level_declaration(declaration, symbol_table, diagnostics);
} }
} }
@ -424,16 +428,16 @@ fn resolve_function_definition(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_parameters( resolve_parameters(
&mut function_definition.parameters, function_definition.parameters_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
resolve_return_type( resolve_return_type(
&mut function_definition.return_type, function_definition.return_type_mut(),
symbol_table, symbol_table,
diagnostics, 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( fn resolve_operator_function_definition(
@ -450,12 +454,12 @@ fn resolve_platform_function_declaration(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_parameters( resolve_parameters(
&mut platform_function_declaration.parameters, platform_function_declaration.parameters_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
resolve_return_type( resolve_return_type(
&mut platform_function_declaration.return_type, platform_function_declaration.return_type_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
@ -467,16 +471,16 @@ fn resolve_interface_function_declaration(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_parameters( resolve_parameters(
&mut interface_function_declaration.parameters, interface_function_declaration.parameters_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
resolve_return_type( resolve_return_type(
&mut interface_function_declaration.return_type, interface_function_declaration.return_type_mut(),
symbol_table, symbol_table,
diagnostics, 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); resolve_function_body(body, symbol_table, diagnostics);
} }
} }
@ -518,7 +522,7 @@ fn resolve_class_constructor(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
use crate::ast::ClassConstructorParameter::*; use crate::ast::ClassConstructorParameter::*;
for parameter in &mut class_constructor.0 { for parameter in class_constructor.parameters_mut() {
match parameter { match parameter {
Property(property) => resolve_property_declaration(property, symbol_table, diagnostics), Property(property) => resolve_property_declaration(property, symbol_table, diagnostics),
Field(field) => resolve_field_declaration(field, symbol_table, diagnostics), Field(field) => resolve_field_declaration(field, symbol_table, diagnostics),
@ -532,7 +536,7 @@ fn resolve_property_declaration(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_type_use( resolve_type_use(
&mut property_declaration.declared_type, property_declaration.declared_type_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
@ -544,7 +548,7 @@ fn resolve_field_declaration(
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_type_use( resolve_type_use(
&mut field_declaration.declared_type, field_declaration.declared_type_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
@ -557,10 +561,10 @@ fn resolve_block_statement(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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); 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); resolve_expression(expression, symbol_table, diagnostics);
} }
} }
@ -591,7 +595,7 @@ fn resolve_variable_declaration(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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) resolve_expression(initializer, symbol_table, diagnostics)
} }
} }
@ -601,8 +605,8 @@ fn resolve_assign_statement(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_expression(&mut assign_statement.lhs, symbol_table, diagnostics); resolve_expression(assign_statement.lhs_mut(), symbol_table, diagnostics);
resolve_expression(&mut assign_statement.rhs, symbol_table, diagnostics); resolve_expression(assign_statement.rhs_mut(), symbol_table, diagnostics);
} }
fn resolve_call_statement( fn resolve_call_statement(
@ -610,7 +614,7 @@ fn resolve_call_statement(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( fn resolve_return_statement(
@ -618,7 +622,7 @@ fn resolve_return_statement(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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); resolve_expression(expression, symbol_table, diagnostics);
} }
} }
@ -737,14 +741,14 @@ fn resolve_ternary_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_expression(&mut ternary_expression.condition, symbol_table, diagnostics); resolve_expression(ternary_expression.condition_mut(), symbol_table, diagnostics);
resolve_expression( resolve_expression(
&mut ternary_expression.true_expression, ternary_expression.true_expression_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
resolve_expression( resolve_expression(
&mut ternary_expression.false_expression, ternary_expression.false_expression_mut(),
symbol_table, symbol_table,
diagnostics, diagnostics,
); );
@ -755,8 +759,8 @@ fn resolve_binary_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_expression(&mut binary_expression.left, symbol_table, diagnostics); resolve_expression(binary_expression.left_mut(), symbol_table, diagnostics);
resolve_expression(&mut binary_expression.right, symbol_table, diagnostics); resolve_expression(binary_expression.right_mut(), symbol_table, diagnostics);
} }
fn resolve_prefix_expression( fn resolve_prefix_expression(
@ -764,7 +768,7 @@ fn resolve_prefix_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( fn resolve_suffix_expression(
@ -772,7 +776,7 @@ fn resolve_suffix_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( fn resolve_call_expression(
@ -780,11 +784,11 @@ fn resolve_call_expression(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, diagnostics: &mut Vec<DmDiagnostic>,
) { ) {
resolve_expression(&mut call_expression.callee, symbol_table, diagnostics); resolve_expression(call_expression.callee_mut(), symbol_table, diagnostics);
if let Some(turbo_fish) = &mut call_expression.turbo_fish { if let Some(turbo_fish) = call_expression.turbo_fish_mut() {
resolve_turbo_fish(turbo_fish, symbol_table, diagnostics); 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( fn resolve_turbo_fish(
@ -792,7 +796,7 @@ fn resolve_turbo_fish(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( fn resolve_call_arguments(
@ -800,7 +804,7 @@ fn resolve_call_arguments(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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); resolve_call_argument(argument, symbol_table, diagnostics);
} }
} }
@ -810,7 +814,7 @@ fn resolve_call_argument(
symbol_table: &mut SymbolTable, symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<DmDiagnostic>, 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( fn resolve_closure(

8
src/name_analysis/symbol.rs
View File

@ -31,8 +31,8 @@ impl SourceDefinition {
#[deprecated(note = "Use identifier instead.")] #[deprecated(note = "Use identifier instead.")]
pub fn from_use_statement(use_statement: &UseStatement) -> Self { pub fn from_use_statement(use_statement: &UseStatement) -> Self {
SourceDefinition { SourceDefinition {
file_id: use_statement.file_id, file_id: use_statement.file_id(),
range: use_statement.range, range: use_statement.range(),
} }
} }
@ -100,12 +100,12 @@ impl UseStatementSymbol {
pub fn new( pub fn new(
fqn: &str, fqn: &str,
declared_name: &str, declared_name: &str,
identifier: Option<Rc<RefCell<Identifier>>>, identifier: Option<&Identifier>,
) -> Self { ) -> Self {
UseStatementSymbol { UseStatementSymbol {
fqn: fqn.to_string(), fqn: fqn.to_string(),
declared_name: declared_name.to_string(), declared_name: declared_name.to_string(),
definition: identifier.map(SourceDefinition::from_identifier_rc), definition: identifier.map(SourceDefinition::from_identifier),
referenced_symbol: None, referenced_symbol: None,
} }
} }