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

Major refactor of frontend ast semantic analysis. WIP.

Browse Source
This commit is contained in:
Jesse Brault 2026-03-20 19:33:52 -05:00
parent 8724c07ae2
commit cf92356585
53 changed files with 2760 additions and 2267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dm/src/main.rs
View File

@ -2,7 +2,7 @@ mod repl;
mod run;
use crate::repl::repl;
use crate::run::run;
use crate::run::compile_and_run_script;
use clap::{Parser, Subcommand};
use std::path::PathBuf;
@ -42,7 +42,7 @@ fn main() {
show_ir,
register_count,
} => {
run(script, *show_asm, *show_ir, *register_count);
compile_and_run_script(script, *show_asm, *show_ir, *register_count);
}
SubCommand::Repl { register_count } => {
repl(*register_count);

21
dm/src/repl.rs
View File

@ -8,6 +8,7 @@ use dmc_lib::lexer::Lexer;
use dmc_lib::parser::parse_expression;
use dmc_lib::symbol_table::SymbolTable;
use dmc_lib::token::TokenKind;
use dmc_lib::types_table::TypesTable;
use dvm_lib::vm::constant::{Constant, StringConstant};
use dvm_lib::vm::function::Function;
use dvm_lib::vm::operand::Operand;
@ -97,24 +98,30 @@ fn compile_expression(
let mut expression = parse_result?;
let mut symbol_table = SymbolTable::new();
let mut types_table = TypesTable::new();
// "fake" scopes
symbol_table.push_module_scope("__repl_module");
symbol_table.push_function_scope("__repl_function");
let function_scope_id = symbol_table.push_function_scope("__repl_function");
expression.gather_declared_names(&mut symbol_table)?;
expression.init_scopes(&mut symbol_table, function_scope_id);
symbol_table.pop_scope(); // function
symbol_table.pop_scope(); // module
expression.check_name_usages(&symbol_table)?;
expression.type_check(&symbol_table)?;
let diagnostics = expression.check_static_fn_local_names(&symbol_table);
if !diagnostics.is_empty() {
return Err(diagnostics);
}
expression.type_check(&symbol_table, &mut types_table)?;
// synthesize a function
let mut ir_builder = IrBuilder::new();
let entry_block_id = ir_builder.new_block();
let maybe_ir_expression = expression.to_ir_expression(&mut ir_builder, &symbol_table);
let maybe_ir_expression =
expression.to_ir_expression(&mut ir_builder, &symbol_table, &types_table);
// if Some, return the value
ir_builder
@ -126,8 +133,8 @@ fn compile_expression(
let mut ir_function = IrFunction::new(
"__repl".into(),
&[],
expression.type_info(),
vec![],
expression.type_info(&symbol_table, &types_table),
entry_block.clone(),
);

54
dm/src/run.rs
View File

@ -7,6 +7,7 @@ use dmc_lib::constants_table::ConstantsTable;
use dmc_lib::diagnostic::Diagnostic;
use dmc_lib::parser::parse_compilation_unit;
use dmc_lib::symbol_table::SymbolTable;
use dmc_lib::types_table::TypesTable;
use dvm_lib::vm::constant::{Constant, StringConstant};
use dvm_lib::vm::function::Function;
use dvm_lib::vm::operand::Operand;
@ -14,45 +15,42 @@ use dvm_lib::vm::{CallStack, DvmContext, call};
use std::path::PathBuf;
use std::rc::Rc;
pub fn run(script: &PathBuf, show_ir: bool, show_asm: bool, register_count: usize) {
pub fn compile_and_run_script(
script: &PathBuf,
show_ir: bool,
show_asm: bool,
register_count: usize,
) {
let input = std::fs::read_to_string(script).unwrap();
let mut files: SimpleFiles<&str, &str> = SimpleFiles::new();
let script_file_id = files.add(script.to_str().unwrap(), &input);
let parse_result = parse_compilation_unit(&input);
let mut compilation_unit = match parse_result {
Ok(compilation_unit) => compilation_unit,
match run(&input, show_ir, show_asm, register_count) {
Ok(_) => {}
Err(diagnostics) => {
check_and_report_diagnostics(&files, script_file_id, &diagnostics);
unreachable!();
}
};
}
}
fn run(
input: &str,
show_ir: bool,
show_asm: bool,
register_count: usize,
) -> Result<(), Vec<Diagnostic>> {
let mut compilation_unit = parse_compilation_unit(&input)?;
let mut symbol_table = SymbolTable::new();
let mut types_table = TypesTable::new();
match compilation_unit.gather_declared_names(&mut symbol_table) {
Ok(_) => {}
Err(diagnostics) => {
report_and_exit(&diagnostics, script_file_id, &files);
}
}
compilation_unit.init_scopes(&mut symbol_table);
compilation_unit.gather_symbols_into(&mut symbol_table)?;
compilation_unit.check_names(&mut symbol_table)?;
compilation_unit.type_check(&symbol_table, &mut types_table)?;
match compilation_unit.check_name_usages(&symbol_table) {
Ok(_) => {}
Err(diagnostics) => {
report_and_exit(&diagnostics, script_file_id, &files);
}
}
match compilation_unit.type_check(&symbol_table) {
Ok(_) => {}
Err(diagnostics) => {
report_and_exit(&diagnostics, script_file_id, &files);
}
}
let (ir_classes, mut ir_functions) = compilation_unit.to_ir(&symbol_table);
let (ir_classes, mut ir_functions) = compilation_unit.to_ir(&symbol_table, &types_table);
if show_ir {
for ir_function in &ir_functions {
@ -117,6 +115,8 @@ pub fn run(script: &PathBuf, show_ir: bool, show_asm: bool, register_count: usiz
if let Some(value) = result {
println!("{}", value);
}
Ok(())
}
fn check_and_report_diagnostics(

228
dmc-lib/src/ast/assign_statement.rs
View File

@ -6,8 +6,10 @@ use crate::error_codes::{ASSIGN_LHS_IMMUTABLE, ASSIGN_MISMATCHED_TYPES, ASSIGN_N
use crate::ir::ir_assign::IrAssign;
use crate::ir::ir_set_field::IrSetField;
use crate::ir::ir_statement::IrStatement;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::expressible_symbol::ExpressibleSymbol;
use crate::symbol_table::SymbolTable;
use crate::types_table::TypesTable;
pub struct AssignStatement {
destination: Box<Expression>,
@ -26,68 +28,68 @@ impl AssignStatement {
&self.destination
}
pub fn gather_declared_names(
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.destination.init_scopes(symbol_table, container_scope);
self.value.init_scopes(symbol_table, container_scope);
}
pub fn check_constructor_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
[
self.destination
.check_constructor_local_names(symbol_table, class_symbol),
self.value
.check_constructor_local_names(symbol_table, class_symbol),
]
.into_iter()
.flatten()
.collect()
}
pub fn check_method_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
[
self.destination
.check_method_local_names(symbol_table, class_symbol),
self.value
.check_method_local_names(symbol_table, class_symbol),
]
.into_iter()
.flatten()
.collect()
}
pub fn check_static_fn_local_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
[
self.destination.check_static_fn_local_names(symbol_table),
self.value.check_static_fn_local_names(symbol_table),
]
.into_iter()
.flatten()
.collect()
}
pub fn type_check(
&mut self,
symbol_table: &mut SymbolTable,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
match self.value.gather_declared_names(symbol_table) {
match self.value.type_check(symbol_table, types_table) {
Ok(_) => {}
Err(mut value_diagnostics) => {
diagnostics.append(&mut value_diagnostics);
}
}
match self.destination.gather_declared_names(symbol_table) {
Ok(_) => {}
Err(mut destination_diagnostics) => {
diagnostics.append(&mut destination_diagnostics);
}
}
if diagnostics.is_empty() {
Ok(())
} else {
Err(diagnostics)
}
}
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
match self.value.check_name_usages(symbol_table) {
Ok(_) => {}
Err(mut value_diagnostics) => {
diagnostics.append(&mut value_diagnostics);
}
}
match self.destination.check_name_usages(symbol_table) {
Ok(_) => {}
Err(mut destination_diagnostics) => {
diagnostics.append(&mut destination_diagnostics);
}
}
if diagnostics.is_empty() {
Ok(())
} else {
Err(diagnostics)
}
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
match self.value.type_check(symbol_table) {
Ok(_) => {}
Err(mut value_diagnostics) => {
diagnostics.append(&mut value_diagnostics);
}
}
match self.destination.type_check(symbol_table) {
match self.destination.type_check(symbol_table, types_table) {
Ok(_) => {}
Err(mut destination_diagnostics) => {
diagnostics.append(&mut destination_diagnostics);
@ -97,10 +99,18 @@ impl AssignStatement {
// check destination is l value
match &*self.destination {
Expression::Identifier(identifier) => {
let expressible_symbol = identifier.expressible_symbol();
let expressible_symbol = symbol_table
.find_expressible_symbol(identifier.scope_id(), identifier.name())
.unwrap();
let is_mut = match &expressible_symbol {
ExpressibleSymbol::Field(field_symbol) => field_symbol.is_mut(),
ExpressibleSymbol::Variable(variable_symbol) => variable_symbol.is_mut(),
_ => false,
};
// check mutable
if !expressible_symbol.is_mut() {
if !is_mut {
let secondary_label = SecondaryLabel::new(
expressible_symbol.source_range().start(),
expressible_symbol.source_range().end(),
@ -119,8 +129,17 @@ impl AssignStatement {
}
// check assignable
let lhs_type = expressible_symbol.type_info();
let rhs_type = self.value.type_info();
let lhs_type = match &expressible_symbol {
ExpressibleSymbol::Field(field_symbol) => {
types_table.field_types().get(field_symbol).unwrap()
}
ExpressibleSymbol::Variable(variable_symbol) => {
types_table.variable_types().get(variable_symbol).unwrap()
}
_ => panic!(),
};
let rhs_type = self.value.type_info(symbol_table, types_table);
if !lhs_type.is_assignable_from(rhs_type) {
let secondary_label = SecondaryLabel::new(
expressible_symbol.source_range().start(),
@ -168,29 +187,37 @@ impl AssignStatement {
}
}
pub fn to_ir(&self, builder: &mut IrBuilder, symbol_table: &SymbolTable) {
pub fn to_ir(
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) {
let destination_symbol = match &*self.destination {
Expression::Identifier(identifier) => identifier.expressible_symbol(),
Expression::Identifier(identifier) => symbol_table
.find_expressible_symbol(identifier.scope_id(), identifier.name())
.unwrap(),
_ => unreachable!("Destination must be a mutable L value"),
};
let ir_statement = match destination_symbol {
ExpressibleSymbol::Field(field_symbol) => {
let mut_field_pointer_variable =
get_or_init_mut_field_pointer_variable(builder, field_symbol).clone();
get_or_init_mut_field_pointer_variable(builder, &field_symbol).clone();
let ir_set_field = IrSetField::new(
&mut_field_pointer_variable,
self.value
.to_ir_expression(builder, symbol_table)
.to_ir_expression(builder, symbol_table, types_table)
.expect("Attempt to convert non-value to value"),
);
IrStatement::SetField(ir_set_field)
}
ExpressibleSymbol::Variable(variable_symbol) => {
let vr_variable = variable_symbol.borrow().vr_variable().clone();
let vr_variable = builder.local_variables().get(&variable_symbol).unwrap();
let ir_assign = IrAssign::new(
vr_variable,
self.value.to_ir_operation(builder, symbol_table),
vr_variable.clone(),
self.value
.to_ir_operation(builder, symbol_table, types_table),
);
IrStatement::Assign(ir_assign)
}
@ -203,12 +230,24 @@ impl AssignStatement {
#[cfg(test)]
mod tests {
use crate::ast::compilation_unit::CompilationUnit;
use crate::diagnostic::Diagnostic;
use crate::error_codes::{ASSIGN_LHS_IMMUTABLE, ASSIGN_MISMATCHED_TYPES, ASSIGN_NO_L_VALUE};
use crate::parser::parse_compilation_unit;
use crate::symbol_table::SymbolTable;
use crate::types_table::TypesTable;
fn compile_up_to_type_check(
compilation_unit: &mut CompilationUnit,
symbol_table: &mut SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
compilation_unit.init_scopes(symbol_table);
compilation_unit.gather_symbols_into(symbol_table)?;
compilation_unit.check_names(symbol_table)
}
#[test]
fn finds_mismatched_types() {
fn finds_mismatched_types() -> Result<(), Vec<Diagnostic>> {
let mut compilation_unit = parse_compilation_unit(
"
fn main()
@ -219,52 +258,41 @@ mod tests {
)
.unwrap();
let mut symbol_table = SymbolTable::new();
compilation_unit
.gather_declared_names(&mut symbol_table)
.unwrap();
compilation_unit.check_name_usages(&symbol_table).unwrap();
match compilation_unit.type_check(&symbol_table) {
Ok(_) => {
panic!("Type check missed diagnostic.");
}
Err(diagnostics) => {
compile_up_to_type_check(&mut compilation_unit, &mut symbol_table)?;
let mut types_table = TypesTable::new();
let diagnostics = compilation_unit
.type_check(&symbol_table, &mut types_table)
.unwrap_err();
assert_eq!(diagnostics.len(), 1);
assert_eq!(
diagnostics[0].error_code().unwrap(),
ASSIGN_MISMATCHED_TYPES
);
}
}
Ok(())
}
#[test]
fn finds_no_l_value() {
fn finds_no_l_value() -> Result<(), Vec<Diagnostic>> {
let mut compilation_unit = parse_compilation_unit(
"
fn main()
42 = 42
end
",
)
.unwrap();
)?;
let mut symbol_table = SymbolTable::new();
compilation_unit
.gather_declared_names(&mut symbol_table)
.unwrap();
compilation_unit.check_name_usages(&symbol_table).unwrap();
match compilation_unit.type_check(&symbol_table) {
Ok(_) => {
panic!("Type check missed diagnostic.");
}
Err(diagnostics) => {
compile_up_to_type_check(&mut compilation_unit, &mut symbol_table)?;
let mut types_table = TypesTable::new();
let diagnostics = compilation_unit
.type_check(&symbol_table, &mut types_table)
.unwrap_err();
assert_eq!(diagnostics.len(), 1);
assert_eq!(diagnostics[0].error_code().unwrap(), ASSIGN_NO_L_VALUE);
}
}
Ok(())
}
#[test]
fn finds_immutable_destination() {
fn finds_immutable_destination() -> Result<(), Vec<Diagnostic>> {
let mut compilation_unit = parse_compilation_unit(
"
fn main()
@ -272,21 +300,15 @@ mod tests {
x = 43
end
",
)
.unwrap();
)?;
let mut symbol_table = SymbolTable::new();
compilation_unit
.gather_declared_names(&mut symbol_table)
.unwrap();
compilation_unit.check_name_usages(&symbol_table).unwrap();
match compilation_unit.type_check(&symbol_table) {
Ok(_) => {
panic!("Type check missed diagnostic.");
}
Err(diagnostics) => {
compile_up_to_type_check(&mut compilation_unit, &mut symbol_table)?;
let mut types_table = TypesTable::new();
let diagnostics = compilation_unit
.type_check(&symbol_table, &mut types_table)
.unwrap_err();
assert_eq!(diagnostics.len(), 1);
assert_eq!(diagnostics[0].error_code().unwrap(), ASSIGN_LHS_IMMUTABLE);
}
}
Ok(())
}
}

128
dmc-lib/src/ast/binary_expression.rs
View File

@ -9,8 +9,10 @@ use crate::ir::ir_operation::IrOperation;
use crate::ir::ir_statement::IrStatement;
use crate::ir::ir_variable::IrVariable;
use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;
use crate::{diagnostics_result, handle_diagnostic, handle_diagnostics, maybe_return_diagnostics};
use std::cell::RefCell;
use std::rc::Rc;
@ -72,45 +74,79 @@ impl BinaryExpression {
self.type_info.as_ref().unwrap()
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
let diagnostics = [&mut self.lhs, &mut self.rhs]
.iter_mut()
.map(|expression| expression.gather_declared_names(symbol_table))
.filter_map(|result| result.err())
.flatten()
.collect::<Vec<Diagnostic>>();
if diagnostics.is_empty() {
Ok(())
} else {
Err(diagnostics)
}
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.lhs.init_scopes(symbol_table, container_scope);
self.rhs.init_scopes(symbol_table, container_scope);
}
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
let diagnostics: Vec<Diagnostic> = [&mut self.lhs, &mut self.rhs]
.iter_mut()
.map(|expression| expression.check_name_usages(symbol_table))
.filter_map(Result::err)
pub fn check_field_initializer_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
[
self.lhs
.check_field_initializer_names(symbol_table, class_symbol),
self.rhs
.check_field_initializer_names(symbol_table, class_symbol),
]
.into_iter()
.flatten()
.collect();
if diagnostics.is_empty() {
Ok(())
} else {
Err(diagnostics)
.collect()
}
pub fn check_constructor_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
[
self.lhs
.check_constructor_local_names(symbol_table, class_symbol),
self.rhs
.check_constructor_local_names(symbol_table, class_symbol),
]
.into_iter()
.flatten()
.collect()
}
pub fn check_method_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
[
self.lhs
.check_method_local_names(symbol_table, class_symbol),
self.rhs
.check_method_local_names(symbol_table, class_symbol),
]
.into_iter()
.flatten()
.collect()
}
pub fn check_static_fn_local_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
[
self.lhs.check_static_fn_local_names(symbol_table),
self.rhs.check_static_fn_local_names(symbol_table),
]
.into_iter()
.flatten()
.collect()
}
fn check_op(
&mut self,
symbol_table: &SymbolTable,
types_table: &TypesTable,
check: impl Fn(&TypeInfo, &TypeInfo) -> bool,
op_result: impl Fn(&TypeInfo, &TypeInfo) -> TypeInfo,
lazy_diagnostic_message: impl Fn(&TypeInfo, &TypeInfo) -> String,
) -> Result<(), Diagnostic> {
let lhs_type_info = self.lhs.type_info();
let rhs_type_info = self.rhs.type_info();
let lhs_type_info = self.lhs.type_info(symbol_table, types_table);
let rhs_type_info = self.rhs.type_info(symbol_table, types_table);
if check(lhs_type_info, rhs_type_info) {
self.type_info = Some(op_result(lhs_type_info, rhs_type_info));
@ -128,11 +164,15 @@ impl BinaryExpression {
}
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
pub fn type_check(
&mut self,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
handle_diagnostics!(self.lhs.type_check(symbol_table), diagnostics);
handle_diagnostics!(self.rhs.type_check(symbol_table), diagnostics);
handle_diagnostics!(self.lhs.type_check(symbol_table, types_table), diagnostics);
handle_diagnostics!(self.rhs.type_check(symbol_table, types_table), diagnostics);
maybe_return_diagnostics!(diagnostics);
@ -140,6 +180,8 @@ impl BinaryExpression {
BinaryOperation::Multiply => {
handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_multiply(rhs),
|lhs, rhs| lhs.multiply_result(rhs),
|lhs, rhs| format!(
@ -153,6 +195,8 @@ impl BinaryExpression {
BinaryOperation::Divide => {
handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_divide(rhs),
|lhs, rhs| lhs.divide_result(rhs),
|lhs, rhs| format!("Incompatible types: cannot divide {} by {}", lhs, rhs)
@ -163,6 +207,8 @@ impl BinaryExpression {
BinaryOperation::Modulo => {
handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_modulo(rhs),
|lhs, rhs| lhs.modulo_result(rhs),
|lhs, rhs| format!("Incompatible types: cannot modulo {} by {}", lhs, rhs)
@ -173,6 +219,8 @@ impl BinaryExpression {
BinaryOperation::Add => {
handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_add(rhs),
|lhs, rhs| lhs.add_result(&rhs),
|lhs, rhs| format!("Incompatible types: cannot add {} to {}.", rhs, lhs)
@ -183,6 +231,8 @@ impl BinaryExpression {
BinaryOperation::Subtract => {
handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_subtract(rhs),
|lhs, rhs| lhs.subtract_result(rhs),
|lhs, rhs| format!(
@ -196,6 +246,8 @@ impl BinaryExpression {
BinaryOperation::LeftShift => {
handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_left_shift(rhs),
|lhs, rhs| lhs.left_shift_result(rhs),
|lhs, rhs| format!(
@ -209,6 +261,8 @@ impl BinaryExpression {
BinaryOperation::RightShift => {
handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_right_shift(rhs),
|lhs, rhs| lhs.right_shift_result(rhs),
|lhs, rhs| format!(
@ -222,6 +276,8 @@ impl BinaryExpression {
BinaryOperation::BitwiseAnd => {
handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_bitwise_and(rhs),
|lhs, rhs| lhs.bitwise_and_result(rhs),
|lhs, rhs| format!(
@ -234,6 +290,8 @@ impl BinaryExpression {
}
BinaryOperation::BitwiseXor => handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_bitwise_xor(rhs),
|lhs, rhs| lhs.bitwise_xor_result(rhs),
|lhs, rhs| format!("Incompatible types: cannot bitwise xor {} by {}", lhs, rhs)
@ -243,6 +301,8 @@ impl BinaryExpression {
BinaryOperation::BitwiseOr => {
handle_diagnostic!(
self.check_op(
symbol_table,
types_table,
|lhs, rhs| lhs.can_bitwise_or(rhs),
|lhs, rhs| lhs.bitwise_or_result(rhs),
|lhs, rhs| format!(
@ -262,14 +322,15 @@ impl BinaryExpression {
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> IrOperation {
let lhs = self
.lhs
.to_ir_expression(builder, symbol_table)
.to_ir_expression(builder, symbol_table, types_table)
.expect("Attempt to use a non-value expression in binary expression.");
let rhs = self
.rhs
.to_ir_expression(builder, symbol_table)
.to_ir_expression(builder, symbol_table, types_table)
.expect("Attempt to use a non-value expression in binary expression.");
let ir_binary_operation = match self.op {
BinaryOperation::Multiply => {
@ -304,8 +365,9 @@ impl BinaryExpression {
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> IrExpression {
let ir_operation = self.to_ir_operation(builder, symbol_table);
let ir_operation = self.to_ir_operation(builder, symbol_table, types_table);
let t_var = IrVariable::new_vr(
builder.new_t_var().into(),
builder.current_block().id(),

177
dmc-lib/src/ast/call.rs
View File

@ -6,15 +6,16 @@ use crate::ir::ir_call::IrCall;
use crate::ir::ir_expression::IrExpression;
use crate::source_range::SourceRange;
use crate::symbol::callable_symbol::CallableSymbol;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::expressible_symbol::ExpressibleSymbol;
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;
pub struct Call {
callee: Box<Expression>,
arguments: Vec<Expression>,
source_range: SourceRange,
return_type_info: Option<TypeInfo>,
}
impl Call {
@ -23,7 +24,6 @@ impl Call {
callee: callee.into(),
arguments,
source_range,
return_type_info: None,
}
}
@ -35,57 +35,92 @@ impl Call {
self.arguments.iter().collect()
}
pub fn gather_declared_names(
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.callee.init_scopes(symbol_table, container_scope);
for argument in &mut self.arguments {
argument.init_scopes(symbol_table, container_scope);
}
}
pub fn check_field_initializer_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
let mut diagnostics: Vec<Diagnostic> = Vec::new();
diagnostics.append(
&mut self
.callee
.check_field_initializer_names(symbol_table, class_symbol),
);
for argument in &self.arguments {
diagnostics
.append(&mut argument.check_field_initializer_names(symbol_table, class_symbol))
}
diagnostics
}
pub fn check_constructor_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
let mut diagnostics = Vec::new();
for argument in &self.arguments {
diagnostics
.append(&mut argument.check_constructor_local_names(symbol_table, class_symbol))
}
diagnostics.append(
&mut self
.callee
.check_constructor_local_names(symbol_table, class_symbol),
);
diagnostics
}
pub fn check_method_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
let mut diagnostics = Vec::new();
for argument in &self.arguments {
diagnostics.append(&mut argument.check_method_local_names(symbol_table, class_symbol));
}
diagnostics.append(
&mut self
.callee
.check_method_local_names(symbol_table, class_symbol),
);
diagnostics
}
pub fn check_static_fn_local_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
let mut diagnostics: Vec<Diagnostic> = Vec::new();
for argument in &self.arguments {
diagnostics.append(&mut argument.check_static_fn_local_names(symbol_table));
}
diagnostics.append(&mut self.callee.check_static_fn_local_names(symbol_table));
diagnostics
}
pub fn type_check(
&mut self,
symbol_table: &mut SymbolTable,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> Result<(), Vec<Diagnostic>> {
let mut to_gather = vec![];
to_gather.push(self.callee.as_mut());
to_gather.extend(&mut self.arguments);
let diagnostics: Vec<Diagnostic> = to_gather
.iter_mut()
.map(|expression| expression.gather_declared_names(symbol_table))
.filter_map(Result::err)
.flatten()
.collect();
if diagnostics.is_empty() {
Ok(())
} else {
Err(diagnostics)
}
}
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
let mut to_check = vec![];
to_check.push(self.callee.as_mut());
to_check.extend(&mut self.arguments);
let diagnostics: Vec<Diagnostic> = to_check
.iter_mut()
.map(|expression| expression.check_name_usages(symbol_table))
.filter_map(Result::err)
.flatten()
.collect();
if diagnostics.is_empty() {
Ok(())
} else {
Err(diagnostics)
}
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
self.callee.as_mut().type_check(symbol_table)?;
self.callee.as_mut().type_check(symbol_table, types_table)?;
let mut diagnostics: Vec<Diagnostic> = self
.arguments
.iter_mut()
.map(|argument| argument.type_check(symbol_table))
.map(|argument| argument.type_check(symbol_table, types_table))
.filter_map(Result::err)
.flatten()
.collect();
// check that callee is callable
let callable_symbol = match self.callee.type_info() {
let callable_symbol = match self.callee.type_info(symbol_table, types_table) {
TypeInfo::Function(function_symbol) => {
CallableSymbol::Function(function_symbol.clone())
}
@ -94,7 +129,7 @@ impl Call {
diagnostics.push(Diagnostic::new(
&format!(
"Receiver of type {} is not callable.",
self.callee.type_info()
self.callee.type_info(symbol_table, types_table)
),
self.callee.source_range().start(),
self.callee.source_range().end(),
@ -103,9 +138,6 @@ impl Call {
}
};
// set return type
self.return_type_info = Some(callable_symbol.return_type_info());
// check arguments length
let parameters = callable_symbol.parameters();
if parameters.len() != self.arguments.len() {
@ -126,10 +158,10 @@ impl Call {
// check argument types
for i in 0..parameters.len() {
let parameter = &parameters[i].borrow();
let parameter = &parameters[i];
let argument = &self.arguments[i];
let parameter_type_info = parameter.type_info();
let argument_type_info = argument.type_info();
let parameter_type_info = types_table.parameter_types().get(parameter).unwrap();
let argument_type_info = argument.type_info(symbol_table, types_table);
if !parameter_type_info.is_assignable_from(argument_type_info) {
diagnostics.push(Diagnostic::new(
&format!(
@ -149,14 +181,30 @@ impl Call {
}
}
pub fn return_type_info(&self) -> &TypeInfo {
self.return_type_info.as_ref().unwrap()
pub fn return_type_info<'a>(
&self,
symbol_table: &SymbolTable,
types_table: &'a TypesTable,
) -> &'a TypeInfo {
let callable_symbol = self.get_callee_symbol(symbol_table);
match callable_symbol {
CallableSymbol::Function(function_symbol) => types_table
.function_return_types()
.get(&function_symbol)
.unwrap(),
CallableSymbol::Class(class_symbol) => types_table
.class_instance_types()
.get(&class_symbol)
.unwrap(),
}
}
fn get_callee_symbol(&self) -> CallableSymbol {
fn get_callee_symbol(&self, symbol_table: &SymbolTable) -> CallableSymbol {
match self.callee() {
Expression::Identifier(identifier) => {
let expressible_symbol = identifier.expressible_symbol();
let expressible_symbol = symbol_table
.find_expressible_symbol(identifier.scope_id(), identifier.name())
.unwrap();
match expressible_symbol {
ExpressibleSymbol::Function(function_symbol) => {
CallableSymbol::Function(function_symbol.clone())
@ -171,11 +219,16 @@ impl Call {
}
}
pub fn to_ir(&self, builder: &mut IrBuilder, symbol_table: &SymbolTable) -> IrCall {
pub fn to_ir(
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> IrCall {
let arguments: Vec<IrExpression> = self
.arguments
.iter()
.map(|argument| argument.to_ir_expression(builder, symbol_table))
.map(|argument| argument.to_ir_expression(builder, symbol_table, types_table))
.inspect(|expression| {
if expression.is_none() {
panic!("Attempt to pass non-expression")
@ -183,21 +236,17 @@ impl Call {
})
.map(Option::unwrap)
.collect();
let callable_symbol = self.get_callee_symbol();
let callable_symbol = self.get_callee_symbol(symbol_table);
match callable_symbol {
CallableSymbol::Function(function_symbol) => IrCall::new(
fqn_parts_to_string(function_symbol.borrow().fqn_parts()),
fqn_parts_to_string(function_symbol.fqn_parts()),
arguments,
function_symbol.borrow().is_extern(),
function_symbol.is_extern(),
),
CallableSymbol::Class(class_symbol) => {
let constructor_symbol = class_symbol
.borrow()
.constructor_symbol()
.cloned()
.expect("Default constructors not supported yet.");
let constructor_symbol = class_symbol.constructor_symbol();
IrCall::new(
fqn_parts_to_string(constructor_symbol.borrow().fqn_parts()),
fqn_parts_to_string(constructor_symbol.fqn_parts()),
arguments,
false,
)

415
dmc-lib/src/ast/class.rs
View File

@ -6,24 +6,21 @@ use crate::ast::fqn_context::FqnContext;
use crate::ast::fqn_util::fqn_parts_to_string;
use crate::ast::function::Function;
use crate::ast::generic_parameter::GenericParameter;
use crate::ast::helpers::{
collect_diagnostics_mut, collect_diagnostics_single, map_symbol_insert_result,
resolve_ctor_name,
};
use crate::ast::helpers::{collect_diagnostics_mut, collect_diagnostics_single, resolve_ctor_name};
use crate::ast::statement::Statement;
use crate::diagnostic::Diagnostic;
use crate::error_codes::{FIELD_MULTIPLE_INIT, FIELD_UNINIT};
use crate::ir::ir_class::{IrClass, IrField};
use crate::ir::ir_function::IrFunction;
use crate::ok_or_err_diagnostics;
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::constructor_symbol::ConstructorSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::generic_parameter_symbol::GenericParameterSymbol;
use crate::symbol::variable_symbol::VariableSymbol;
use crate::symbol_table::SymbolTable;
use crate::{ok_or_err_diagnostics, push_ok_or_push_errs};
use std::cell::{Ref, RefCell, RefMut};
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;
use std::collections::{HashMap, HashSet};
use std::rc::Rc;
@ -34,7 +31,7 @@ pub struct Class {
constructor: Option<Constructor>,
fields: Vec<Field>,
functions: Vec<Function>,
class_symbol: Option<Rc<RefCell<ClassSymbol>>>,
scope_id: Option<usize>,
}
impl Class {
@ -53,258 +50,146 @@ impl Class {
constructor,
fields,
functions,
class_symbol: None,
scope_id: None,
}
}
/// Returns a [ClassSymbol] representing this class.
fn make_class_symbol(&self, fqn_context: &FqnContext) -> ClassSymbol {
ClassSymbol::new(
&self.declared_name,
self.declared_name_source_range.clone(),
fqn_context.resolve(&self.declared_name),
false,
)
}
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.scope_id = Some(container_scope);
/// Inserts the given [ClassSymbol] into the `symbol_table`, returning `Ok` if the insert was
/// successful, else `Err` with diagnostics.
fn insert_class_symbol(
&mut self,
symbol_table: &mut SymbolTable,
class_symbol: ClassSymbol,
) -> Result<Rc<RefCell<ClassSymbol>>, Vec<Diagnostic>> {
map_symbol_insert_result(
symbol_table.insert_class_symbol(class_symbol),
&self.declared_name_source_range,
)
}
/// Sets this class' class symbol to the given symbol.
fn set_class_symbol(&mut self, symbol: Rc<RefCell<ClassSymbol>>) {
self.class_symbol = Some(symbol);
}
/// Gathers names of this class' generic parameters, returning `Ok` if all
/// [GenericParameter]s produced an `Ok(GenericParameterSymbol)`, else `Err`.
fn gather_generic_parameters_names(
&mut self,
symbol_table: &mut SymbolTable,
) -> Result<Vec<Rc<RefCell<GenericParameterSymbol>>>, Vec<Diagnostic>> {
let mut symbols: Vec<Rc<RefCell<GenericParameterSymbol>>> = vec![];
let mut diagnostics: Vec<Diagnostic> = vec![];
let class_scope =
symbol_table.push_class_scope(&format!("class_scope({})", self.declared_name));
for generic_parameter in &mut self.generic_parameters {
push_ok_or_push_errs!(
generic_parameter.gather_declared_names(symbol_table),
symbols,
diagnostics
);
generic_parameter.init_scopes(symbol_table, class_scope);
}
ok_or_err_diagnostics!(symbols, diagnostics)
let class_body_scope =
symbol_table.push_class_scope(&format!("class_body_scope({})", self.declared_name));
for field in &mut self.fields {
field.init_scopes(symbol_table, class_body_scope);
}
/// Returns a [Ref] to this class' [ClassSymbol]. Only safe to call if the class symbol has been
/// set.
fn use_class_symbol(&self) -> Ref<ClassSymbol> {
self.class_symbol.as_ref().unwrap().borrow()
if let Some(constructor) = &mut self.constructor {
constructor.init_scopes(symbol_table, class_body_scope);
}
for function in &mut self.functions {
function.init_scopes(symbol_table, class_body_scope);
}
/// Returns a [RefMut] to this class' [ClassSymbol]. Only safe to call if the class symbol has
/// been set.
fn use_class_symbol_mut(&mut self) -> RefMut<ClassSymbol> {
self.class_symbol.as_mut().unwrap().borrow_mut()
symbol_table.pop_scope();
symbol_table.pop_scope();
}
/// Sets the given [GenericParameterSymbol]s on this class' [ClassSymbol].
fn set_generic_parameters_on_class_symbol(
&mut self,
generic_parameter_symbols: Vec<Rc<RefCell<GenericParameterSymbol>>>,
) {
self.use_class_symbol_mut()
.set_generic_parameters(generic_parameter_symbols);
pub fn make_symbols(&self, fqn_context: &mut FqnContext) -> Vec<Symbol> {
let mut all_symbols: Vec<Symbol> = Vec::new();
let mut generic_parameter_symbols = Vec::new();
for generic_parameter in &self.generic_parameters {
let symbol = Rc::new(generic_parameter.make_symbol());
all_symbols.push(Symbol::GenericParameter(symbol.clone()));
generic_parameter_symbols.push(symbol);
}
/// Returns `Ok` of [FieldSymbol]s if all of this class' fields [Field::gather_declared_names]
/// methods return `Ok`, else `Err` of [Diagnostic]s.
fn gather_fields_names(
&mut self,
symbol_table: &mut SymbolTable,
) -> Result<Vec<Rc<RefCell<FieldSymbol>>>, Vec<Diagnostic>> {
let mut symbols: Vec<Rc<RefCell<FieldSymbol>>> = vec![];
let mut diagnostics: Vec<Diagnostic> = vec![];
for (field_index, field) in self.fields.iter_mut().enumerate() {
push_ok_or_push_errs!(
field.gather_declared_names(symbol_table, field_index),
symbols,
diagnostics
);
let mut field_symbols = Vec::new();
for field in &self.fields {
let symbol = Rc::new(field.make_symbol());
all_symbols.push(Symbol::Field(symbol.clone()));
field_symbols.push(symbol);
}
ok_or_err_diagnostics!(symbols, diagnostics)
}
fqn_context.push(self.declared_name.clone()); // namespace this class' members
/// Converts the given `field_symbols` [Vec] into a [HashMap] of field names to [FieldSymbol]s.
fn make_fields_hash_map(
field_symbols: Vec<Rc<RefCell<FieldSymbol>>>,
) -> HashMap<Rc<str>, Rc<RefCell<FieldSymbol>>> {
HashMap::from_iter(
field_symbols
.into_iter()
.map(|field| {
let name = field.borrow().declared_name_owned();
(name, field)
})
.collect::<Vec<_>>(),
)
}
/// Sets the field symbols property on the class' [ClassSymbol].
fn set_field_symbols_on_class_symbol(&mut self, field_symbols: Vec<Rc<RefCell<FieldSymbol>>>) {
self.use_class_symbol_mut()
.set_fields(Self::make_fields_hash_map(field_symbols))
}
/// Returns a [ConstructorSymbol] representing a default constructor appropriate for this class.
fn make_default_constructor(&self, fqn_context: &FqnContext) -> ConstructorSymbol {
ConstructorSymbol::new(
self.declared_name_source_range.clone(),
let constructor_symbol = if let Some(constructor) = &self.constructor {
let (constructor_symbol, mut symbols) = constructor.make_symbols(fqn_context);
all_symbols.append(&mut symbols);
constructor_symbol
} else {
Rc::new(ConstructorSymbol::new(
&self.declared_name_source_range,
resolve_ctor_name(fqn_context),
false,
true,
)
self.scope_id.unwrap(),
vec![],
))
};
all_symbols.push(Symbol::Constructor(constructor_symbol.clone()));
let mut function_symbols = Vec::new();
for function in &self.functions {
let (function_symbol, mut symbols) = function.make_symbols(fqn_context, true);
all_symbols.append(&mut symbols);
function_symbols.push(function_symbol);
}
/// Gathers names in the class' [Constructor] and returns a [ConstructorSymbol], if the
/// constructor is present; else returns a symbol defining a default constructor.
fn gather_constructor_names(
&mut self,
symbol_table: &mut SymbolTable,
fqn_context: &FqnContext,
) -> Result<Rc<RefCell<ConstructorSymbol>>, Vec<Diagnostic>> {
if let Some(constructor) = &mut self.constructor {
constructor.gather_declared_names(symbol_table, fqn_context)
} else {
Ok(Rc::new(RefCell::new(
self.make_default_constructor(fqn_context),
)))
}
fqn_context.pop(); // un-namespace
let class_symbol = Rc::new(ClassSymbol::new(
&self.declared_name,
&self.declared_name_source_range,
fqn_context.resolve(&self.declared_name),
false,
self.scope_id.unwrap(),
generic_parameter_symbols,
constructor_symbol,
field_symbols,
function_symbols,
));
all_symbols.push(Symbol::Class(class_symbol.clone()));
all_symbols
}
/// Sets the constructor symbol on this class' [ClassSymbol].
fn set_constructor_symbol_on_class_symbol(
&mut self,
constructor_symbol: Rc<RefCell<ConstructorSymbol>>,
) {
self.use_class_symbol_mut()
.set_constructor_symbol(constructor_symbol);
pub fn check_names(&self, symbol_table: &mut SymbolTable) -> Vec<Diagnostic> {
let mut diagnostics: Vec<Diagnostic> = Vec::new();
for generic_parameter in &self.generic_parameters {
diagnostics.append(&mut generic_parameter.check_names(symbol_table));
}
/// Gathers function names and returns `Ok` if no diagnostics, else `Err`.
fn gather_functions_names(
&mut self,
symbol_table: &mut SymbolTable,
fqn_context: &FqnContext,
) -> Result<(), Vec<Diagnostic>> {
collect_diagnostics_mut(&mut self.functions, |f| {
f.gather_declared_names(symbol_table, fqn_context, self.class_symbol.as_ref())
})
for field in &self.fields {
diagnostics.append(&mut field.check_names(symbol_table));
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
fqn_context: &mut FqnContext,
) -> Result<(), Vec<Diagnostic>> {
// 1. Make and insert class symbol
let to_insert = self.make_class_symbol(fqn_context);
let class_symbol = self.insert_class_symbol(symbol_table, to_insert)?;
self.set_class_symbol(class_symbol);
// 2. Push class name on fqn context
fqn_context.push(self.declared_name.clone());
// 3. push scope
symbol_table.push_class_scope(&format!("class_scope({})", self.declared_name));
// 4. gather generic parameters
let generic_parameter_symbols = self
.gather_generic_parameters_names(symbol_table)
.inspect_err(|_| {
symbol_table.pop_scope();
fqn_context.pop();
})?;
self.set_generic_parameters_on_class_symbol(generic_parameter_symbols);
// 5. gather fields
let field_symbols = self.gather_fields_names(symbol_table).inspect_err(|_| {
symbol_table.pop_scope();
fqn_context.pop();
})?;
self.set_field_symbols_on_class_symbol(field_symbols);
// 6. gather constructor
let constructor_symbol = self
.gather_constructor_names(symbol_table, fqn_context)
.inspect_err(|_| {
symbol_table.pop_scope();
fqn_context.pop();
})?;
self.set_constructor_symbol_on_class_symbol(constructor_symbol);
// 7. gather functions
self.gather_functions_names(symbol_table, fqn_context)
.inspect_err(|_| {
symbol_table.pop_scope();
fqn_context.pop();
})?;
// 8. pop scope
symbol_table.pop_scope();
// 9. pop fqn part
fqn_context.pop();
Ok(())
if let Some(constructor) = &self.constructor {
diagnostics.append(&mut constructor.check_names(symbol_table));
}
fn check_generics_names(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
collect_diagnostics_mut(&mut self.generic_parameters, |gp| {
gp.check_name_usages(symbol_table, self.class_symbol.as_ref())
})
for function in &self.functions {
diagnostics.append(&mut function.check_names(symbol_table));
}
/// Checks the [Constructor]'s name usages if present.
fn check_constructor_names(
&mut self,
symbol_table: &SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
if let Some(constructor) = &mut self.constructor {
constructor.check_name_usages(symbol_table, self.class_symbol.as_ref())?
}
Ok(())
diagnostics
}
fn check_fields_names(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
collect_diagnostics_mut(&mut self.fields, |f| {
f.check_name_usages(symbol_table, self.class_symbol.as_ref())
})
pub fn check_field_initializer_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
let class_symbol = symbol_table
.get_class_symbol(self.scope_id.unwrap(), &self.declared_name)
.cloned()
.unwrap();
self.fields
.iter()
.flat_map(|field| field.check_field_initializer_names(symbol_table, &class_symbol))
.collect()
}
fn check_functions_names(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
collect_diagnostics_mut(&mut self.functions, |f| {
f.check_name_usages(symbol_table, self.class_symbol.as_ref())
})
}
pub fn analyze_local_names(&self, symbol_table: &mut SymbolTable) -> Vec<Diagnostic> {
let class_symbol = symbol_table
.get_class_symbol(self.scope_id.unwrap(), &self.declared_name)
.cloned()
.unwrap();
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
self.check_generics_names(symbol_table)?;
self.check_constructor_names(symbol_table)?;
self.check_fields_names(symbol_table)?;
self.check_functions_names(symbol_table)?;
Ok(())
let mut diagnostics: Vec<Diagnostic> = Vec::new();
if let Some(constructor) = &self.constructor {
diagnostics.append(&mut constructor.analyze_local_names(symbol_table, &class_symbol));
}
for function in &self.functions {
diagnostics
.append(&mut function.analyze_method_local_names(symbol_table, &class_symbol));
}
diagnostics
}
fn type_check_generics(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
@ -313,22 +198,35 @@ impl Class {
})
}
fn type_check_fields(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
collect_diagnostics_mut(&mut self.fields, |f| f.type_check(symbol_table))
fn type_check_fields(
&mut self,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> Result<(), Vec<Diagnostic>> {
collect_diagnostics_mut(&mut self.fields, |f| {
f.type_check(symbol_table, types_table)
})
}
fn type_check_constructor(
&mut self,
symbol_table: &SymbolTable,
types_table: &mut TypesTable,
) -> Result<(), Vec<Diagnostic>> {
if let Some(constructor) = &mut self.constructor {
constructor.type_check(symbol_table)?;
constructor.type_check(symbol_table, types_table)?;
}
Ok(())
}
fn type_check_functions(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
collect_diagnostics_mut(&mut self.functions, |f| f.type_check(symbol_table))
fn type_check_functions(
&mut self,
symbol_table: &SymbolTable,
types_table: &mut TypesTable,
) -> Result<(), Vec<Diagnostic>> {
collect_diagnostics_mut(&mut self.functions, |f| {
f.type_check(symbol_table, types_table)
})
}
/// Returns all field names with declared initializers.
@ -350,16 +248,14 @@ impl Class {
&self,
assign_statement: &'a AssignStatement,
fields_already_init: &HashSet<&&str>,
class_symbol: &ClassSymbol,
) -> Result<Option<&'a str>, Diagnostic> {
match assign_statement.destination() {
Expression::Identifier(identifier) => {
// find matching field symbol, if there is one
if let Some(field_symbol) = self.use_class_symbol().fields().get(identifier.name())
{
if let Some(field_symbol) = class_symbol.fields().get(identifier.name()) {
// check that we don't init more than once IF field is immutable
if fields_already_init.contains(&identifier.name())
&& !field_symbol.borrow().is_mut()
{
if fields_already_init.contains(&identifier.name()) && !field_symbol.is_mut() {
let diagnostic = Diagnostic::new(
&format!("Immutable field {} cannot be initialized more than once in constructor.", identifier.name()),
identifier.source_range().start(),
@ -388,19 +284,25 @@ impl Class {
fn get_fields_init_in_ctor<'a>(
&self,
fields_with_declared_initializers: &HashSet<&str>,
symbol_table: &SymbolTable,
) -> Result<HashSet<&str>, Vec<Diagnostic>> {
let mut constructor_inits: HashSet<&str> = HashSet::new();
let mut diagnostics: Vec<Diagnostic> = vec![];
if let Some(constructor) = &self.constructor {
let class_symbol = symbol_table
.get_class_symbol(self.scope_id.unwrap(), &self.declared_name)
.unwrap();
for statement in constructor.statements() {
match statement {
Statement::Assign(assign_statement) => {
let fields_init_so_far = constructor_inits
.union(fields_with_declared_initializers)
.collect::<HashSet<_>>();
match self
.check_ctor_assign_statement(assign_statement, &fields_init_so_far)
{
match self.check_ctor_assign_statement(
assign_statement,
&fields_init_so_far,
&class_symbol,
) {
Ok(maybe_init_field) => match maybe_init_field {
None => {}
Some(init_field) => {
@ -445,14 +347,17 @@ impl Class {
/// Immutable fields may be only initialized once, either at their declaration or once in the
/// constructor. Mutable fields may be initialized either at their declaration, or at least once
/// in the constructor.
fn check_field_initialization(&self) -> Result<(), Vec<Diagnostic>> {
fn check_field_initialization(
&self,
symbol_table: &SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
// We need to determine if fields are initialized or not (the latter is an error).
// First phase: check all fields, then check constructor, leaving pending those things that
// are fields <- initialized by constructor. Then circle back to fields and check all are
// initialized
let field_names_with_initializers = self.field_names_with_initializers();
let field_names_init_in_constructor =
self.get_fields_init_in_ctor(&field_names_with_initializers)?;
self.get_fields_init_in_ctor(&field_names_with_initializers, symbol_table)?;
let combined = field_names_with_initializers
.union(&field_names_init_in_constructor)
.collect::<HashSet<_>>();
@ -463,35 +368,45 @@ impl Class {
Ok(())
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
pub fn type_check(
&mut self,
symbol_table: &SymbolTable,
types_table: &mut TypesTable,
) -> Result<(), Vec<Diagnostic>> {
self.type_check_generics(symbol_table)?;
self.type_check_fields(symbol_table)?;
self.type_check_constructor(symbol_table)?;
self.type_check_functions(symbol_table)?;
self.check_field_initialization()?;
self.type_check_fields(symbol_table, types_table)?;
self.type_check_constructor(symbol_table, types_table)?;
self.type_check_functions(symbol_table, types_table)?;
self.check_field_initialization(symbol_table)?;
Ok(())
}
pub fn to_ir(&self, symbol_table: &SymbolTable) -> (IrClass, Vec<IrFunction>) {
pub fn to_ir(
&self,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> (IrClass, Vec<IrFunction>) {
let self_class_symbol = symbol_table
.get_class_symbol(self.scope_id.unwrap(), &self.declared_name)
.unwrap();
let mut ir_functions: Vec<IrFunction> = vec![];
if let Some(constructor) = &self.constructor {
ir_functions.push(constructor.to_ir(
self.class_symbol.as_ref().unwrap(),
self_class_symbol,
&self.fields,
symbol_table,
types_table,
))
}
for function in &self.functions {
ir_functions
.push(function.to_ir(symbol_table, Some(self.class_symbol.as_ref().unwrap())));
ir_functions.push(function.to_ir(symbol_table, types_table, Some(self_class_symbol)));
}
let class_symbol = self.class_symbol.as_ref().unwrap().borrow();
let ir_class = IrClass::new(
class_symbol.declared_name_owned(),
fqn_parts_to_string(class_symbol.fqn_parts()).into(),
self_class_symbol.declared_name_owned(),
fqn_parts_to_string(self_class_symbol.fqn_parts()).into(),
self.fields
.iter()
.map(|field| {

117
dmc-lib/src/ast/compilation_unit.rs
View File

@ -2,12 +2,13 @@ use crate::ast::class::Class;
use crate::ast::extern_function::ExternFunction;
use crate::ast::fqn_context::FqnContext;
use crate::ast::function::Function;
use crate::ast::helpers::collect_diagnostics_into_mut;
use crate::ast::helpers::{collect_diagnostics_into_mut, try_insert_symbols_into};
use crate::diagnostic::Diagnostic;
use crate::diagnostics_result;
use crate::ir::ir_class::IrClass;
use crate::ir::ir_function::IrFunction;
use crate::symbol_table::SymbolTable;
use crate::types_table::TypesTable;
use crate::{diagnostics_result, handle_diagnostics};
pub struct CompilationUnit {
functions: Vec<Function>,
@ -40,68 +41,70 @@ impl CompilationUnit {
&self.classes
}
pub fn gather_declared_names(
&mut self,
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable) {
let compilation_unit_scope = symbol_table.push_module_scope("compilation_unit_scope");
for class in &mut self.classes {
class.init_scopes(symbol_table, compilation_unit_scope);
}
for function in &mut self.functions {
function.init_scopes(symbol_table, compilation_unit_scope);
}
for extern_function in &mut self.extern_functions {
extern_function.init_scopes(symbol_table, compilation_unit_scope);
}
symbol_table.pop_scope();
}
pub fn gather_symbols_into(
&self,
symbol_table: &mut SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
symbol_table.push_module_scope("compilation_unit_scope");
let mut fqn_context = FqnContext::new(); // in the future, we'll push the pkg/ns on here
let mut diagnostics: Vec<Diagnostic> = vec![];
collect_diagnostics_into_mut(
&mut self.functions,
|f| f.gather_declared_names(symbol_table, &fqn_context, None),
&mut diagnostics,
let mut diagnostics = vec![];
let mut fqn_context = FqnContext::new();
for class in &self.classes {
handle_diagnostics!(
try_insert_symbols_into(class.make_symbols(&mut fqn_context), symbol_table),
diagnostics
);
collect_diagnostics_into_mut(
&mut self.extern_functions,
|ef| ef.gather_declared_names(symbol_table, &fqn_context),
&mut diagnostics,
);
collect_diagnostics_into_mut(
&mut self.classes,
|c| c.gather_declared_names(symbol_table, &mut fqn_context),
&mut diagnostics,
);
symbol_table.pop_scope();
}
for function in &self.functions {
let (_, symbols) = function.make_symbols(&mut fqn_context, false);
handle_diagnostics!(try_insert_symbols_into(symbols, symbol_table), diagnostics);
}
for extern_function in &self.extern_functions {
let (_, symbols) = extern_function.make_symbols(&mut fqn_context);
handle_diagnostics!(try_insert_symbols_into(symbols, symbol_table), diagnostics);
}
diagnostics_result!(diagnostics)
}
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
collect_diagnostics_into_mut(
&mut self.functions,
|f| f.check_name_usages(symbol_table, None),
&mut diagnostics,
);
collect_diagnostics_into_mut(
&mut self.extern_functions,
|ef| ef.check_name_usages(symbol_table, None),
&mut diagnostics,
);
collect_diagnostics_into_mut(
&mut self.classes,
|c| c.check_name_usages(symbol_table),
&mut diagnostics,
);
pub fn check_names(&self, symbol_table: &mut SymbolTable) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics = vec![];
for class in &self.classes {
diagnostics.append(&mut class.check_names(symbol_table));
diagnostics.append(&mut class.check_field_initializer_names(symbol_table));
diagnostics.append(&mut class.analyze_local_names(symbol_table));
}
for function in &self.functions {
diagnostics.append(&mut function.check_names(symbol_table));
diagnostics.append(&mut function.analyze_static_fn_local_names(symbol_table));
}
for extern_function in &self.extern_functions {
diagnostics.append(&mut extern_function.check_names(symbol_table));
}
diagnostics_result!(diagnostics)
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
pub fn type_check(
&mut self,
symbol_table: &SymbolTable,
types_table: &mut TypesTable,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
collect_diagnostics_into_mut(
&mut self.functions,
|f| f.type_check(symbol_table),
|f| f.type_check(symbol_table, types_table),
&mut diagnostics,
);
@ -113,24 +116,28 @@ impl CompilationUnit {
collect_diagnostics_into_mut(
&mut self.classes,
|c| c.type_check(symbol_table),
|c| c.type_check(symbol_table, types_table),
&mut diagnostics,
);
diagnostics_result!(diagnostics)
}
pub fn to_ir(&self, symbol_table: &SymbolTable) -> (Vec<IrClass>, Vec<IrFunction>) {
pub fn to_ir(
&self,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> (Vec<IrClass>, Vec<IrFunction>) {
let mut functions: Vec<IrFunction> = vec![];
let mut classes: Vec<IrClass> = vec![];
self.functions
.iter()
.map(|f| f.to_ir(symbol_table, None))
.map(|f| f.to_ir(symbol_table, types_table, None))
.for_each(|f| functions.push(f));
for class in &self.classes {
let (class, mut class_functions) = class.to_ir(symbol_table);
let (class, mut class_functions) = class.to_ir(symbol_table, types_table);
functions.append(&mut class_functions);
classes.push(class);
}

187
dmc-lib/src/ast/constructor.rs
View File

@ -1,7 +1,7 @@
use crate::ast::field::Field;
use crate::ast::fqn_context::FqnContext;
use crate::ast::fqn_util::fqn_parts_to_string;
use crate::ast::helpers::resolve_ctor_name;
use crate::ast::helpers::{collect_parameter_symbols_into, resolve_ctor_name};
use crate::ast::ir_builder::IrBuilder;
use crate::ast::parameter::Parameter;
use crate::ast::statement::Statement;
@ -22,9 +22,9 @@ use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::constructor_symbol::ConstructorSymbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol_table::{SymbolInsertError, SymbolTable};
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;
use std::cell::RefCell;
use std::ops::Neg;
use std::rc::Rc;
@ -34,6 +34,7 @@ pub struct Constructor {
ctor_keyword_source_range: SourceRange,
parameters: Vec<Parameter>,
statements: Vec<Statement>,
scope_id: Option<usize>,
}
impl Constructor {
@ -48,6 +49,7 @@ impl Constructor {
ctor_keyword_source_range,
parameters,
statements,
scope_id: None,
}
}
@ -55,112 +57,67 @@ impl Constructor {
&self.statements
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
fqn_context: &FqnContext,
) -> Result<Rc<RefCell<ConstructorSymbol>>, Vec<Diagnostic>> {
// insert constructor symbol
let to_insert = ConstructorSymbol::new(
self.ctor_keyword_source_range.clone(),
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.scope_id = Some(container_scope);
let function_scope = symbol_table.push_function_scope("constructor_scope");
for parameter in &mut self.parameters {
parameter.init_scopes(symbol_table, function_scope);
}
let body_scope = symbol_table.push_block_scope("body_scope");
for statement in &mut self.statements {
statement.init_scopes(symbol_table, body_scope);
}
symbol_table.pop_scope();
symbol_table.pop_scope();
}
pub fn make_symbols(&self, fqn_context: &FqnContext) -> (Rc<ConstructorSymbol>, Vec<Symbol>) {
let mut all_symbols: Vec<Symbol> = Vec::new();
let mut parameter_symbols = Vec::new();
collect_parameter_symbols_into(&self.parameters, &mut all_symbols, &mut parameter_symbols);
let constructor_symbol = Rc::new(ConstructorSymbol::new(
&self.ctor_keyword_source_range,
resolve_ctor_name(fqn_context),
false,
false,
);
let constructor_symbol =
symbol_table
.insert_constructor_symbol(to_insert)
.map_err(|symbol_insert_error| match symbol_insert_error {
SymbolInsertError::AlreadyDeclared(_) => {
vec![
Diagnostic::new(
"Cannot declare more than one constructor.",
self.ctor_keyword_source_range.start(),
self.ctor_keyword_source_range.end(),
)
.with_reporter(file!(), line!()),
]
}
})?;
self.scope_id.unwrap(),
parameter_symbols,
));
all_symbols.push(Symbol::Constructor(constructor_symbol.clone()));
symbol_table.push_function_scope("ctor_scope");
let mut parameter_symbols: Vec<Rc<RefCell<ParameterSymbol>>> = vec![];
let mut parameters_diagnostics = vec![];
for parameter in &mut self.parameters {
match parameter.gather_declared_names(symbol_table) {
Ok(parameter_symbol) => {
parameter_symbols.push(parameter_symbol);
}
Err(mut ds) => {
parameters_diagnostics.append(&mut ds);
}
}
(constructor_symbol, all_symbols)
}
if !parameters_diagnostics.is_empty() {
symbol_table.pop_scope();
return Err(parameters_diagnostics);
} else {
constructor_symbol
.borrow_mut()
.set_parameters(parameter_symbols);
pub fn check_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
let mut diagnostics: Vec<Diagnostic> = Vec::new();
for parameter in &self.parameters {
diagnostics.append(&mut parameter.check_names(symbol_table));
}
diagnostics
}
symbol_table.push_block_scope("ctor_main_block");
let statements_diagnostics = self
.statements
.iter_mut()
.map(|stmt| stmt.gather_declared_names(symbol_table))
.filter_map(Result::err)
.flatten()
.collect::<Vec<_>>();
symbol_table.pop_scope(); // block
symbol_table.pop_scope(); // function
if statements_diagnostics.is_empty() {
Ok(constructor_symbol)
} else {
Err(statements_diagnostics)
}
pub fn analyze_local_names(
&self,
symbol_table: &mut SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
self.statements
.iter()
.flat_map(|s| s.analyze_constructor_local_names(symbol_table, class_symbol))
.collect()
}
pub fn check_name_usages(
pub fn type_check(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
types_table: &mut TypesTable,
) -> Result<(), Vec<Diagnostic>> {
let parameters_diagnostics: Vec<Diagnostic> = self
.parameters
.iter_mut()
.map(|param| param.check_name_usages(symbol_table, class_context))
.filter_map(Result::err)
.flatten()
.collect();
if !parameters_diagnostics.is_empty() {
return Err(parameters_diagnostics);
}
let statements_diagnostics: Vec<Diagnostic> = self
.statements
.iter_mut()
.map(|statement| statement.check_name_usages(symbol_table))
.filter_map(Result::err)
.flatten()
.collect();
if statements_diagnostics.is_empty() {
Ok(())
} else {
Err(statements_diagnostics)
}
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
let parameters_diagnostics: Vec<Diagnostic> = self
.parameters
.iter_mut()
@ -176,7 +133,7 @@ impl Constructor {
let statements_diagnostics: Vec<Diagnostic> = self
.statements
.iter_mut()
.map(|statement| statement.type_check(symbol_table, None))
.map(|statement| statement.type_check(symbol_table, types_table, None))
.filter_map(Result::err)
.flatten()
.collect();
@ -190,9 +147,10 @@ impl Constructor {
pub fn to_ir(
&self,
class_symbol: &Rc<RefCell<ClassSymbol>>,
class_symbol: &Rc<ClassSymbol>,
fields: &[Field],
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> IrFunction {
let mut ir_builder = IrBuilder::new();
@ -202,17 +160,22 @@ impl Constructor {
.iter()
.enumerate()
.map(|(i, parameter)| {
let mut parameter_symbol = parameter.parameter_symbol().borrow_mut();
let parameter_symbol = symbol_table
.get_parameter_symbol_owned(parameter.scope_id(), parameter.declared_name())
.unwrap();
let parameter_type = types_table
.parameter_types()
.get(&parameter_symbol)
.unwrap();
let offset = (parameters_count as isize).neg() + i as isize;
let ir_parameter = Rc::new(IrParameter::new(
parameter_symbol.declared_name(),
parameter_symbol.type_info().clone(),
parameter_type.clone(),
offset,
));
// make sure to save ir_parameter to symbol so others can access it
let to_save = ir_parameter.clone();
parameter_symbol.set_ir_parameter(to_save);
ir_builder.push_parameter(&parameter_symbol, ir_parameter.clone());
ir_parameter
})
@ -234,7 +197,7 @@ impl Constructor {
let alloc_assign = IrAssign::new(
self_variable.clone(),
IrOperation::Allocate(IrAllocate::new(class_symbol.borrow().declared_name_owned())),
IrOperation::Allocate(IrAllocate::new(class_symbol.declared_name_owned())),
);
ir_builder
.current_block_mut()
@ -275,7 +238,7 @@ impl Constructor {
.clone();
let ir_expression = initializer
.to_ir_expression(&mut ir_builder, symbol_table)
.to_ir_expression(&mut ir_builder, symbol_table, types_table)
.unwrap();
let ir_set_field = IrSetField::new(
&field_mut_ref_variable, // dumb that we clone it and then ref it
@ -289,7 +252,7 @@ impl Constructor {
// do "declared" statements of constructor
for statement in &self.statements {
statement.to_ir(&mut ir_builder, symbol_table, false);
statement.to_ir(&mut ir_builder, symbol_table, types_table, false);
}
// return complete self object
@ -303,16 +266,12 @@ impl Constructor {
ir_builder.finish_block();
let entry_block = ir_builder.get_block(entry_block_id);
let constructor_symbol = symbol_table
.get_constructor_symbol(self.scope_id.unwrap())
.unwrap();
IrFunction::new(
fqn_parts_to_string(
class_symbol
.borrow()
.constructor_symbol()
.unwrap()
.borrow()
.fqn_parts(),
), // fake function symbol
&ir_parameters, // make params
fqn_parts_to_string(constructor_symbol.fqn_parts()),
ir_parameters,
&TypeInfo::ClassInstance(class_symbol.clone()),
entry_block.clone(),
)

88
dmc-lib/src/ast/diagnostic_factories.rs Normal file
View File

@ -0,0 +1,88 @@
use crate::diagnostic::{Diagnostic, SecondaryLabel};
use crate::error_codes::{
OUTER_CLASS_FIELD_USED_IN_INIT, OUTER_CLASS_METHOD_USED_IN_INIT, SELF_CONSTRUCTOR_USED_IN_INIT,
SELF_FIELD_USED_IN_INIT, SELF_METHOD_USED_IN_INIT, SYMBOL_ALREADY_DECLARED, SYMBOL_NOT_FOUND,
};
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
pub fn symbol_not_found(name: &str, source_range: &SourceRange) -> Diagnostic {
Diagnostic::new(
&format!("Symbol {} not found in scope.", name),
source_range.start(),
source_range.end(),
)
.with_error_code(SYMBOL_NOT_FOUND)
}
pub fn cannot_reference_field_in_init(name: &str, source_range: &SourceRange) -> Diagnostic {
Diagnostic::new(
&format!("Cannot reference field {} during initialization.", name),
source_range.start(),
source_range.end(),
)
.with_error_code(SELF_FIELD_USED_IN_INIT)
}
pub fn symbol_already_declared(already_inserted: &Symbol, would_insert: &Symbol) -> Diagnostic {
let secondary_label = SecondaryLabel::new(
already_inserted.declared_name_source_range().start(),
already_inserted.declared_name_source_range().end(),
Some("Symbol already declared here.".to_string()),
);
Diagnostic::new(
&format!(
"Symbol {} already declared in current scope.",
would_insert.declared_name()
),
would_insert.declared_name_source_range().start(),
would_insert.declared_name_source_range().end(),
)
.with_error_code(SYMBOL_ALREADY_DECLARED)
.with_secondary_labels(&[secondary_label])
}
pub fn self_constructor_used_in_init(source_range: &SourceRange) -> Diagnostic {
Diagnostic::new(
"Cannot call Self constructor during initialization.",
source_range.start(),
source_range.end(),
)
.with_error_code(SELF_CONSTRUCTOR_USED_IN_INIT)
}
pub fn self_field_used_in_init(source_range: &SourceRange) -> Diagnostic {
Diagnostic::new(
"Cannot reference Self field during initialization.",
source_range.start(),
source_range.end(),
)
.with_error_code(SELF_FIELD_USED_IN_INIT)
}
pub fn self_method_used_in_init(source_range: &SourceRange) -> Diagnostic {
Diagnostic::new(
"Cannot call Self method during initialization.",
source_range.start(),
source_range.end(),
)
.with_error_code(SELF_METHOD_USED_IN_INIT)
}
pub fn outer_class_field_usage(source_range: &SourceRange) -> Diagnostic {
Diagnostic::new(
"Cannot reference an outer class member.",
source_range.start(),
source_range.end(),
)
.with_error_code(OUTER_CLASS_FIELD_USED_IN_INIT)
}
pub fn outer_class_method_usage(source_range: &SourceRange) -> Diagnostic {
Diagnostic::new(
"Cannot call an outer class method.",
source_range.start(),
source_range.end(),
)
.with_error_code(OUTER_CLASS_METHOD_USED_IN_INIT)
}

219
dmc-lib/src/ast/expression.rs
View File

@ -13,8 +13,10 @@ use crate::ir::ir_operation::IrOperation;
use crate::ir::ir_statement::IrStatement;
use crate::ir::ir_variable::IrVariable;
use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;
use std::cell::RefCell;
use std::rc::Rc;
@ -29,61 +31,164 @@ pub enum Expression {
}
impl Expression {
pub fn gather_declared_names(
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
match self {
Expression::Binary(binary_expression) => {
binary_expression.init_scopes(symbol_table, container_scope);
}
Expression::Negative(negative_expression) => {
negative_expression.init_scopes(symbol_table, container_scope);
}
Expression::Call(call) => {
call.init_scopes(symbol_table, container_scope);
}
Expression::Identifier(identifier) => {
identifier.init_scope_id(container_scope);
}
_ => {}
}
}
pub fn check_field_initializer_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
match self {
Expression::Binary(binary_expression) => {
binary_expression.check_field_initializer_names(symbol_table, class_symbol)
}
Expression::Negative(negative_expression) => {
negative_expression.check_field_initializer_names(symbol_table, class_symbol)
}
Expression::Call(call) => {
call.check_field_initializer_names(symbol_table, class_symbol)
}
Expression::Identifier(identifier) => {
if let Some(diagnostic) =
identifier.check_name_as_field_initializer(symbol_table, class_symbol)
{
vec![diagnostic]
} else {
vec![]
}
}
_ => vec![],
}
}
pub fn check_constructor_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
match self {
Expression::Binary(binary_expression) => {
binary_expression.check_constructor_local_names(symbol_table, class_symbol)
}
Expression::Negative(negative_expression) => {
negative_expression.check_constructor_local_names(symbol_table, class_symbol)
}
Expression::Call(call) => {
call.check_constructor_local_names(symbol_table, class_symbol)
}
Expression::Identifier(identifier) => {
if let Some(diagnostic) =
identifier.check_constructor_local_name(symbol_table, class_symbol)
{
vec![diagnostic]
} else {
vec![]
}
}
_ => vec![],
}
}
pub fn check_method_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
match self {
Expression::Binary(binary_expression) => {
binary_expression.check_method_local_names(symbol_table, class_symbol)
}
Expression::Negative(negative_expression) => {
negative_expression.check_method_local_names(symbol_table, class_symbol)
}
Expression::Call(call) => call.check_method_local_names(symbol_table, class_symbol),
Expression::Identifier(identifier) => {
if let Some(diagnostic) =
identifier.check_method_local_name(symbol_table, class_symbol)
{
vec![diagnostic]
} else {
vec![]
}
}
_ => vec![],
}
}
pub fn check_static_fn_local_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
match self {
Expression::Binary(binary_expression) => {
binary_expression.check_static_fn_local_names(symbol_table)
}
Expression::Negative(negative_expression) => {
negative_expression.check_static_fn_local_names(symbol_table)
}
Expression::Call(call) => call.check_static_fn_local_names(symbol_table),
Expression::Identifier(identifier) => {
if let Some(diagnostic) = identifier.check_static_fn_local_name(symbol_table) {
vec![diagnostic]
} else {
vec![]
}
}
Expression::Integer(_) => {
vec![]
}
Expression::Double(_) => {
vec![]
}
Expression::String(_) => {
vec![]
}
}
}
pub fn type_check(
&mut self,
symbol_table: &mut SymbolTable,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> Result<(), Vec<Diagnostic>> {
match self {
Expression::Binary(binary_expression) => {
binary_expression.gather_declared_names(symbol_table)
binary_expression.type_check(symbol_table, types_table)
}
Expression::Negative(negative_expression) => {
negative_expression.gather_declared_names(symbol_table)
negative_expression.type_check(symbol_table, types_table)
}
Expression::Call(call) => call.gather_declared_names(symbol_table),
Expression::Identifier(identifier) => identifier.gather_declared_names(symbol_table),
Expression::Call(call) => call.type_check(symbol_table, types_table),
Expression::Identifier(_) => Ok(()),
Expression::Integer(_) => Ok(()),
Expression::Double(_) => Ok(()),
Expression::String(_) => Ok(()),
}
}
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
match self {
Expression::Binary(binary_expression) => {
binary_expression.check_name_usages(symbol_table)
}
Expression::Negative(negative_expression) => {
negative_expression.check_name_usages(symbol_table)
}
Expression::Call(call) => call.check_name_usages(symbol_table),
Expression::Identifier(identifier) => identifier.check_name_usages(symbol_table),
Expression::Integer(_) => Ok(()),
Expression::Double(_) => Ok(()),
Expression::String(_) => Ok(()),
}
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
match self {
Expression::Binary(binary_expression) => binary_expression.type_check(symbol_table),
Expression::Negative(negative_expression) => {
negative_expression.type_check(symbol_table)
}
Expression::Call(call) => call.type_check(symbol_table),
Expression::Identifier(identifier) => identifier.type_check(symbol_table),
Expression::Integer(_) => Ok(()),
Expression::Double(_) => Ok(()),
Expression::String(_) => Ok(()),
}
}
pub fn type_info(&self) -> &TypeInfo {
pub fn type_info<'a>(
&'a self,
symbol_table: &SymbolTable,
types_table: &'a TypesTable,
) -> &'a TypeInfo {
match self {
Expression::Binary(binary_expression) => binary_expression.type_info(),
Expression::Negative(negative_expression) => negative_expression.type_info(),
Expression::Call(call) => call.return_type_info(),
Expression::Identifier(identifier) => identifier.type_info(),
Expression::Call(call) => call.return_type_info(symbol_table, types_table),
Expression::Identifier(identifier) => identifier.type_info(symbol_table, types_table),
Expression::Integer(integer_literal) => integer_literal.type_info(),
Expression::Double(double_literal) => double_literal.type_info(),
Expression::String(string_literal) => string_literal.type_info(),
@ -106,12 +211,15 @@ impl Expression {
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> IrOperation {
match self {
Expression::Binary(binary_expression) => {
binary_expression.to_ir_operation(builder, symbol_table)
binary_expression.to_ir_operation(builder, symbol_table, types_table)
}
Expression::Call(call) => {
IrOperation::Call(call.to_ir(builder, symbol_table, types_table))
}
Expression::Call(call) => IrOperation::Call(call.to_ir(builder, symbol_table)),
Expression::Integer(integer_literal) => {
IrOperation::Load(IrExpression::Int(integer_literal.value()))
}
@ -122,10 +230,10 @@ impl Expression {
IrOperation::Load(IrExpression::String(string_literal.content().into()))
}
Expression::Identifier(identifier) => {
IrOperation::Load(identifier.expressible_symbol().ir_expression(builder))
IrOperation::Load(identifier.ir_expression(builder, symbol_table))
}
Expression::Negative(negative_expression) => {
IrOperation::Load(negative_expression.to_ir(builder, symbol_table))
IrOperation::Load(negative_expression.to_ir(builder, symbol_table, types_table))
}
}
}
@ -134,14 +242,21 @@ impl Expression {
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> Option<IrExpression> {
match self {
Expression::Binary(binary_expression) => {
Some(binary_expression.to_ir_expression(builder, symbol_table))
Some(binary_expression.to_ir_expression(builder, symbol_table, types_table))
}
Expression::Negative(negative_expression) => {
Some(negative_expression.to_ir(builder, symbol_table, types_table))
}
Expression::Call(call) => {
let ir_call = call.to_ir(builder, symbol_table);
if matches!(call.return_type_info(), TypeInfo::Void) {
let ir_call = call.to_ir(builder, symbol_table, types_table);
if matches!(
call.return_type_info(symbol_table, types_table),
TypeInfo::Void
) {
builder
.current_block_mut()
.add_statement(IrStatement::Call(ir_call));
@ -150,7 +265,7 @@ impl Expression {
let t_var = IrVariable::new_vr(
builder.new_t_var().into(),
builder.current_block().id(),
call.return_type_info(),
call.return_type_info(symbol_table, types_table),
);
let as_rc = Rc::new(RefCell::new(t_var));
let assign = IrAssign::new(as_rc.clone(), IrOperation::Call(ir_call));
@ -160,6 +275,9 @@ impl Expression {
Some(IrExpression::Variable(as_rc))
}
}
Expression::Identifier(identifier) => {
Some(identifier.ir_expression(builder, symbol_table))
}
Expression::Integer(integer_literal) => {
Some(IrExpression::Int(integer_literal.value()))
}
@ -169,13 +287,6 @@ impl Expression {
Expression::String(string_literal) => {
Some(IrExpression::String(string_literal.content().into()))
}
Expression::Identifier(identifier) => {
let expressible_symbol = identifier.expressible_symbol();
Some(expressible_symbol.ir_expression(builder))
}
Expression::Negative(negative_expression) => {
Some(negative_expression.to_ir(builder, symbol_table))
}
}
}
}

41
dmc-lib/src/ast/expression_statement.rs
View File

@ -3,8 +3,10 @@ use crate::ast::ir_builder::IrBuilder;
use crate::diagnostic::Diagnostic;
use crate::ir::ir_return::IrReturn;
use crate::ir::ir_statement::IrStatement;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;
pub struct ExpressionStatement {
expression: Box<Expression>,
@ -21,26 +23,42 @@ impl ExpressionStatement {
&self.expression
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
self.expression.gather_declared_names(symbol_table)
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.expression.init_scopes(symbol_table, container_scope);
}
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
self.expression.check_name_usages(symbol_table)
pub fn check_constructor_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
self.expression
.check_constructor_local_names(symbol_table, class_symbol)
}
pub fn check_method_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
self.expression
.check_method_local_names(symbol_table, class_symbol)
}
pub fn check_static_fn_local_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
self.expression.check_static_fn_local_names(symbol_table)
}
pub fn type_check(
&mut self,
symbol_table: &SymbolTable,
types_table: &TypesTable,
must_return_type_info: Option<&TypeInfo>,
) -> Result<(), Vec<Diagnostic>> {
self.expression.type_check(symbol_table)?;
self.expression.type_check(symbol_table, types_table)?;
if must_return_type_info.is_some() {
let expression_type = self.expression.type_info();
let expression_type = self.expression.type_info(symbol_table, types_table);
let return_type = must_return_type_info.unwrap();
if !return_type.is_assignable_from(expression_type) {
return Err(vec![Diagnostic::new(
@ -60,9 +78,12 @@ impl ExpressionStatement {
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
should_return_value: bool,
) {
let ir_expression = self.expression.to_ir_expression(builder, symbol_table);
let ir_expression = self
.expression
.to_ir_expression(builder, symbol_table, types_table);
if ir_expression.is_some() && should_return_value {
builder
.current_block_mut()

164
dmc-lib/src/ast/extern_function.rs
View File

@ -1,21 +1,22 @@
use crate::ast::fqn_context::FqnContext;
use crate::ast::helpers::{collect_diagnostics_into_mut, gather_oks, map_symbol_insert_result};
use crate::ast::helpers::{collect_diagnostics_into_mut, collect_parameter_symbols_into};
use crate::ast::parameter::Parameter;
use crate::ast::type_use::TypeUse;
use crate::diagnostic::Diagnostic;
use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::Symbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol_table::SymbolTable;
use crate::{diagnostics_result, handle_diagnostics, maybe_return_diagnostics, ok_or_return};
use crate::{diagnostics_result, handle_diagnostics};
use std::cell::RefCell;
use std::rc::Rc;
pub struct ExternFunction {
declared_name: String,
declared_name: Rc<str>,
declared_name_source_range: SourceRange,
parameters: Vec<Parameter>,
return_type: TypeUse,
scope_id: Option<usize>,
function_symbol: Option<Rc<RefCell<FunctionSymbol>>>,
}
@ -31,6 +32,7 @@ impl ExternFunction {
declared_name_source_range,
parameters,
return_type,
scope_id: None,
function_symbol: None,
}
}
@ -39,140 +41,46 @@ impl ExternFunction {
&self.declared_name
}
/// Inserts and saves a `FunctionSymbol`.
fn insert_save_function_symbol(
&mut self,
symbol_table: &mut SymbolTable,
fqn_context: &FqnContext,
) -> Result<(), Vec<Diagnostic>> {
let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new(
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.scope_id = Some(container_scope);
symbol_table.push_function_scope(&format!("extern_function_scope({})", self.declared_name));
for parameter in &mut self.parameters {
parameter.init_scopes(symbol_table, container_scope);
}
self.return_type.init_scopes(symbol_table, container_scope);
symbol_table.pop_scope();
}
pub fn make_symbols(&self, fqn_context: &FqnContext) -> (Rc<FunctionSymbol>, Vec<Symbol>) {
let mut all_symbols: Vec<Symbol> = Vec::new();
let mut parameter_symbols = Vec::new();
collect_parameter_symbols_into(&self.parameters, &mut all_symbols, &mut parameter_symbols);
let function_symbol = Rc::new(FunctionSymbol::new(
&self.declared_name,
self.declared_name_source_range.clone(),
fqn_context.resolve(self.declared_name()),
true,
false,
self.scope_id.unwrap(),
parameter_symbols,
));
all_symbols.push(Symbol::Function(function_symbol.clone()));
let function_symbol = ok_or_return!(map_symbol_insert_result(
insert_result,
&self.declared_name_source_range
));
self.function_symbol = Some(function_symbol);
Ok(())
(function_symbol, all_symbols)
}
/// Gathers parameters' declared names, and sets `ParameterSymbols` on the `FunctionSymbol`.
fn gather_parameters_names(
&mut self,
symbol_table: &mut SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
let parameter_symbols = gather_oks(
&mut self.parameters,
|p| p.gather_declared_names(symbol_table),
&mut diagnostics,
);
// Only continue if we have all the parameters and no diagnostics.
maybe_return_diagnostics!(diagnostics);
self.function_symbol
.as_mut()
.unwrap()
.borrow_mut()
.set_parameters(parameter_symbols);
Ok(())
pub fn check_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
let mut diagnostics: Vec<Diagnostic> = Vec::new();
for parameter in &self.parameters {
diagnostics.append(&mut parameter.check_names(symbol_table));
}
/// Gathers return type names
fn gather_return_type_names(
&mut self,
symbol_table: &mut SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
handle_diagnostics!(
self.return_type.gather_declared_names(symbol_table),
diagnostics.append(&mut self.return_type.check_names(symbol_table));
diagnostics
);
diagnostics_result!(diagnostics)
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
fqn_context: &FqnContext,
) -> Result<(), Vec<Diagnostic>> {
self.insert_save_function_symbol(symbol_table, fqn_context)?;
symbol_table
.push_function_scope(&format!("extern_function_scope({})", &self.declared_name));
self.gather_parameters_names(symbol_table)
.inspect_err(|_| symbol_table.pop_scope())?; // pop scope if we had diagnostics!
// handle return type
self.gather_return_type_names(symbol_table)
.inspect_err(|_| symbol_table.pop_scope())?;
symbol_table.pop_scope(); // function scope
Ok(())
}
fn check_parameters_names(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
diagnostics: &mut Vec<Diagnostic>,
) {
collect_diagnostics_into_mut(
&mut self.parameters,
|p| p.check_name_usages(symbol_table, class_context),
diagnostics,
);
}
fn check_return_type_names(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
diagnostics: &mut Vec<Diagnostic>,
) {
handle_diagnostics!(
self.return_type
.check_name_usages(symbol_table, class_context),
diagnostics
);
}
/// Sets the `FunctionSymbol`'s return type info.
fn set_function_symbol_return_type(&mut self) {
self.function_symbol
.as_mut()
.unwrap()
.borrow_mut()
.set_return_type_info(self.return_type.type_info().clone());
}
pub fn check_name_usages(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
self.check_parameters_names(symbol_table, class_context, &mut diagnostics);
self.check_return_type_names(symbol_table, class_context, &mut diagnostics);
maybe_return_diagnostics!(diagnostics);
// set return type info on symbol now that its available
self.set_function_symbol_return_type();
Ok(())
}
fn type_check_parameters(

105
dmc-lib/src/ast/field.rs
View File

@ -4,7 +4,8 @@ use crate::diagnostic::Diagnostic;
use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol_table::{SymbolInsertError, SymbolTable};
use crate::symbol_table::SymbolTable;
use crate::types_table::TypesTable;
use std::cell::RefCell;
use std::rc::Rc;
@ -15,6 +16,7 @@ pub struct Field {
is_mut: bool,
declared_type: Option<Box<TypeUse>>,
initializer: Option<Box<Expression>>,
scope_id: Option<usize>,
field_symbol: Option<Rc<RefCell<FieldSymbol>>>,
}
@ -34,6 +36,7 @@ impl Field {
is_mut,
declared_type: declared_type.map(Box::new),
initializer: initializer.map(Box::new),
scope_id: None,
field_symbol: None,
}
}
@ -54,77 +57,50 @@ impl Field {
self.initializer.as_ref().map(Box::as_ref)
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
field_index: usize,
) -> Result<Rc<RefCell<FieldSymbol>>, Vec<Diagnostic>> {
// 1. insert field symbol
let to_insert = FieldSymbol::new(
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.scope_id = Some(container_scope);
if let Some(type_use) = &mut self.declared_type {
type_use.init_scopes(symbol_table, container_scope);
}
if let Some(expression) = &mut self.initializer {
expression.init_scopes(symbol_table, container_scope);
}
}
pub fn make_symbol(&self) -> FieldSymbol {
FieldSymbol::new(
&self.declared_name,
self.declared_name_source_range.clone(),
self.is_mut,
);
let field_symbol = symbol_table
.insert_field_symbol(to_insert)
.map_err(|e| match e {
SymbolInsertError::AlreadyDeclared(already_declared) => {
vec![Diagnostic::new(
&format!(
"Symbol {} already declared in current scope.",
already_declared.symbol().borrow().declared_name()
),
self.declared_name_source_range.start(),
self.declared_name_source_range.end(),
)]
}
})?;
// save for later
let to_return = field_symbol.clone();
self.field_symbol = Some(field_symbol);
// set field index on symbol
self.field_symbol
.as_ref()
.unwrap()
.borrow_mut()
.set_field_index(field_index);
// 2. gather type_use and initializer, if present
if let Some(type_use) = &mut self.declared_type {
type_use.gather_declared_names(symbol_table)?;
self.scope_id.unwrap(),
)
}
if let Some(initializer) = &mut self.initializer {
initializer.gather_declared_names(symbol_table)?;
pub fn check_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
let mut diagnostics: Vec<Diagnostic> = Vec::new();
if let Some(type_use) = &self.declared_type {
diagnostics.append(&mut type_use.check_names(symbol_table));
}
diagnostics
}
Ok(to_return)
pub fn check_field_initializer_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
if let Some(initializer) = &self.initializer {
initializer.check_field_initializer_names(symbol_table, class_symbol)
} else {
vec![]
}
}
pub fn check_name_usages(
pub fn type_check(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
types_table: &TypesTable,
) -> Result<(), Vec<Diagnostic>> {
if let Some(type_use) = &mut self.declared_type {
type_use.check_name_usages(symbol_table, class_context)?;
}
// This is going to get hairy, because users might attempt to use a field in an initializer
// (for either this field, or another one) before it's actually initialized. As such, we
// need a way to prevent lookup of current class' fields in the initializer.
// For now, the following is okay so long as we don't start referencing things in the
// initializers.
if let Some(initializer) = self.initializer.as_mut() {
initializer.check_name_usages(symbol_table)?;
}
Ok(())
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
if let Some(type_use) = &mut self.declared_type {
@ -134,7 +110,9 @@ impl Field {
}
if let Some(initializer) = &mut self.initializer {
if let Some(mut initializer_diagnostics) = initializer.type_check(symbol_table).err() {
if let Some(mut initializer_diagnostics) =
initializer.type_check(symbol_table, types_table).err()
{
diagnostics.append(&mut initializer_diagnostics);
}
}
@ -149,7 +127,8 @@ impl Field {
Some(type_use) => {
match self.initializer.as_ref() {
Some(initializer) => {
let initializer_type_info = initializer.type_info();
let initializer_type_info =
initializer.type_info(symbol_table, types_table);
let declared_type_info = type_use.type_info();
if declared_type_info.is_assignable_from(initializer_type_info) {
declared_type_info
@ -176,7 +155,7 @@ impl Field {
None => {
// type is the initializer
match self.initializer.as_ref() {
Some(initializer) => initializer.type_info(),
Some(initializer) => initializer.type_info(symbol_table, types_table),
None => {
// this is an error
return Err(vec![Diagnostic::new(

363
dmc-lib/src/ast/function.rs
View File

@ -1,8 +1,8 @@
use crate::ast::fqn_context::FqnContext;
use crate::ast::fqn_util::fqn_parts_to_string;
use crate::ast::helpers::{
collect_diagnostics_into_enumerated_mut, collect_diagnostics_into_mut, gather_oks,
map_symbol_insert_result,
collect_diagnostics_into_enumerated_mut, collect_diagnostics_into_mut,
collect_parameter_symbols_into,
};
use crate::ast::ir_builder::IrBuilder;
use crate::ast::parameter::Parameter;
@ -18,19 +18,19 @@ use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::{diagnostics_result, handle_diagnostics, maybe_return_diagnostics, ok_or_return};
use std::cell::RefCell;
use crate::types_table::TypesTable;
use crate::{diagnostics_result, handle_diagnostics};
use std::ops::Neg;
use std::rc::Rc;
pub struct Function {
declared_name: String,
declared_name: Rc<str>,
declared_name_source_range: SourceRange,
is_public: bool,
parameters: Vec<Parameter>,
return_type: Option<TypeUse>,
statements: Vec<Statement>,
function_symbol: Option<Rc<RefCell<FunctionSymbol>>>,
scope_id: Option<usize>,
}
impl Function {
@ -43,13 +43,13 @@ impl Function {
statements: Vec<Statement>,
) -> Self {
Self {
declared_name: declared_name.to_string(),
declared_name: declared_name.into(),
declared_name_source_range,
is_public,
parameters,
return_type,
statements,
function_symbol: None,
scope_id: None,
}
}
@ -61,220 +61,91 @@ impl Function {
self.statements.iter().collect()
}
/// Inserts a "self" parameter at index 0.
fn insert_self_parameter(&mut self) {
self.parameters.insert(
0,
Parameter::new(
"self",
SourceRange::new(0, 0),
TypeUse::new("Self", SourceRange::new(0, 0), vec![]),
),
);
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.scope_id = Some(container_scope);
let function_scope =
symbol_table.push_function_scope(&format!("function_scope({})", self.declared_name));
for parameter in &mut self.parameters {
parameter.init_scopes(symbol_table, function_scope);
}
if let Some(type_use) = &mut self.return_type {
type_use.init_scopes(symbol_table, function_scope);
}
/// If `class_context` is `Some`, calls `insert_self_parameter()`.
fn maybe_insert_self_parameter(&mut self, class_context: Option<&Rc<RefCell<ClassSymbol>>>) {
if class_context.is_some() {
self.insert_self_parameter();
}
let body_scope =
symbol_table.push_block_scope(&format!("body_scope({})", self.declared_name));
for statement in &mut self.statements {
statement.init_scopes(symbol_table, body_scope);
}
/// Inserts and saves to self a `FunctionSymbol`
fn insert_save_function_symbol(
&mut self,
symbol_table: &mut SymbolTable,
symbol_table.pop_scope(); // body
symbol_table.pop_scope(); // function
}
pub fn make_symbols(
&self,
fqn_context: &FqnContext,
) -> Result<(), Vec<Diagnostic>> {
let insert_result = symbol_table.insert_function_symbol(FunctionSymbol::new(
self.declared_name(),
is_method: bool,
) -> (Rc<FunctionSymbol>, Vec<Symbol>) {
let mut all_symbols: Vec<Symbol> = vec![];
let mut parameter_symbols = Vec::new();
collect_parameter_symbols_into(&self.parameters, &mut all_symbols, &mut parameter_symbols);
let function_symbol = Rc::new(FunctionSymbol::new(
&self.declared_name,
self.declared_name_source_range.clone(),
fqn_context.resolve(self.declared_name()),
false,
is_method,
self.scope_id.unwrap(),
parameter_symbols,
));
all_symbols.push(Symbol::Function(function_symbol.clone()));
// get function symbol if successful
let function_symbol = ok_or_return!(map_symbol_insert_result(
insert_result,
&self.declared_name_source_range
));
// save function symbol for later
self.function_symbol = Some(function_symbol.clone());
Ok(())
(function_symbol, all_symbols)
}
/// Gathers all declared names in parameters
fn gather_parameters_names(
&mut self,
pub fn check_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
let mut diagnostics = Vec::new();
for parameter in &self.parameters {
diagnostics.append(&mut parameter.check_names(symbol_table));
}
if let Some(type_use) = &self.return_type {
diagnostics.append(&mut type_use.check_names(symbol_table));
}
diagnostics
}
pub fn analyze_method_local_names(
&self,
symbol_table: &mut SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
) -> Result<(), Vec<Diagnostic>> {
// handle self case
self.maybe_insert_self_parameter(class_context);
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
self.statements
.iter()
.flat_map(|statement| statement.analyze_method_local_names(symbol_table, class_symbol))
.collect()
}
let mut diagnostics: Vec<Diagnostic> = vec![];
pub fn analyze_static_fn_local_names(&self, symbol_table: &mut SymbolTable) -> Vec<Diagnostic> {
self.statements
.iter()
.flat_map(|statement| statement.analyze_static_fn_local_names(symbol_table))
.collect()
}
// now gather all names for the params
let parameter_symbols = gather_oks(
&mut self.parameters,
|p| p.gather_declared_names(symbol_table),
&mut diagnostics,
);
// important: if there were diagnostics we don't have all the param symbols
// n.b.: passing pop_scope callback because we don't want to mess up the scopes for others
maybe_return_diagnostics!(diagnostics);
// set params on function symbol
self.function_symbol
.as_mut()
fn get_return_type_info(
types_table: &TypesTable,
function_symbol: &FunctionSymbol,
) -> TypeInfo {
types_table
.function_return_types()
.get(function_symbol)
.cloned()
.unwrap()
.borrow_mut()
.set_parameters(parameter_symbols);
Ok(())
}
/// Gathers all return type names
fn gather_return_type_names(
&mut self,
symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<Diagnostic>,
) {
collect_diagnostics_into_mut(
self.return_type.as_mut_slice(),
|type_use| type_use.gather_declared_names(symbol_table),
diagnostics,
);
}
/// Gathers all statements' names
fn gather_statements_names(
&mut self,
symbol_table: &mut SymbolTable,
diagnostics: &mut Vec<Diagnostic>,
) {
collect_diagnostics_into_mut(
&mut self.statements,
|s| s.gather_declared_names(symbol_table),
diagnostics,
);
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
fqn_context: &FqnContext,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
) -> Result<(), Vec<Diagnostic>> {
// function symbol
self.insert_save_function_symbol(symbol_table, fqn_context)?;
// parameters
symbol_table.push_function_scope(&format!("function_scope({})", self.declared_name));
self.gather_parameters_names(symbol_table, class_context)
.inspect_err(|_| symbol_table.pop_scope())?; // if we errored, we need to fix scopes
// return type
let mut diagnostics = vec![];
self.gather_return_type_names(symbol_table, &mut diagnostics);
// enter main block
symbol_table.push_block_scope(&format!("main_block_scope({})", self.declared_name));
// statements
self.gather_statements_names(symbol_table, &mut diagnostics);
symbol_table.pop_scope(); // main block scope
symbol_table.pop_scope(); // function scope
diagnostics_result!(diagnostics)
}
/// Checks parameter name usages
fn check_parameter_names(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
diagnostics: &mut Vec<Diagnostic>,
) {
collect_diagnostics_into_mut(
&mut self.parameters,
|p| p.check_name_usages(symbol_table, class_context),
diagnostics,
);
}
/// Checks return type name usages, if there is a `TypeUse` present. If `None`, sets the
/// `FunctionSymbol`'s return type to `TypeInfo::Void`.
fn check_return_type_names(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
diagnostics: &mut Vec<Diagnostic>,
) {
if let Some(type_use) = &mut self.return_type {
match type_use.check_name_usages(symbol_table, class_context) {
Ok(_) => {
// set return type info on function symbol
self.function_symbol
.as_mut()
.unwrap()
.borrow_mut()
.set_return_type_info(type_use.type_info().clone());
}
Err(mut type_use_diagnostics) => {
diagnostics.append(&mut type_use_diagnostics);
}
}
} else {
// we don't have a given return type, so it's void
self.function_symbol
.as_mut()
.unwrap()
.borrow_mut()
.set_return_type_info(TypeInfo::Void);
}
}
/// Checks all statement name usages.
fn check_statement_names(
&mut self,
symbol_table: &SymbolTable,
diagnostics: &mut Vec<Diagnostic>,
) {
collect_diagnostics_into_mut(
&mut self.statements,
|s| s.check_name_usages(symbol_table),
diagnostics,
);
}
pub fn check_name_usages(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics = vec![];
// parameters
self.check_parameter_names(symbol_table, class_context, &mut diagnostics);
// return type
self.check_return_type_names(symbol_table, class_context, &mut diagnostics);
// statements
self.check_statement_names(symbol_table, &mut diagnostics);
diagnostics_result!(diagnostics)
}
/// Gets the return type `TypeInfo`. This function is only safe to call after an `Ok` call to
/// `check_return_type_names()`.
fn get_return_type_info(&self) -> TypeInfo {
let function_symbol = self.function_symbol.as_ref().unwrap().borrow();
function_symbol.return_type_info().clone()
}
/// Type checks parameters.
@ -305,9 +176,11 @@ impl Function {
fn type_check_statements(
&mut self,
symbol_table: &SymbolTable,
types_table: &mut TypesTable,
diagnostics: &mut Vec<Diagnostic>,
function_symbol: &FunctionSymbol,
) {
let return_type_info = self.get_return_type_info();
let return_type_info = Self::get_return_type_info(types_table, function_symbol);
let statements_len = self.statements.len();
collect_diagnostics_into_enumerated_mut(
@ -315,17 +188,24 @@ impl Function {
|i, s| {
let is_last = i == statements_len - 1;
if is_last {
s.type_check(symbol_table, Some(&return_type_info))
s.type_check(symbol_table, types_table, Some(&return_type_info))
} else {
s.type_check(symbol_table, None)
s.type_check(symbol_table, types_table, None)
}
},
diagnostics,
);
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
pub fn type_check(
&mut self,
symbol_table: &SymbolTable,
types_table: &mut TypesTable,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics = vec![];
let function_symbol = symbol_table
.get_function_symbol(self.scope_id.unwrap(), self.declared_name())
.unwrap();
// parameters
self.type_check_parameters(symbol_table, &mut diagnostics);
@ -334,33 +214,39 @@ impl Function {
self.type_check_return_type(symbol_table, &mut diagnostics);
// statements
self.type_check_statements(symbol_table, &mut diagnostics);
self.type_check_statements(symbol_table, types_table, &mut diagnostics, function_symbol);
diagnostics_result!(diagnostics)
}
/// Converts all parameters to ir. Saves the IrParameter to the associated parameter symbol.
fn parameters_to_ir(&self, builder: &mut IrBuilder) {
fn parameters_to_ir(
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) {
for (i, parameter) in self.parameters.iter().enumerate() {
let parameter_symbol = parameter.parameter_symbol();
let parameter_symbol = symbol_table
.get_parameter_symbol_owned(parameter.scope_id(), parameter.declared_name())
.unwrap();
let parameter_type_info = types_table
.parameter_types()
.get(&parameter_symbol)
.unwrap();
let stack_offset = (self.parameters.len() as isize).neg() + (i as isize);
let ir_parameter = IrParameter::new(
parameter_symbol.borrow().declared_name(),
parameter_symbol.borrow().type_info().clone(),
parameter_symbol.declared_name(),
parameter_type_info.clone(),
stack_offset,
);
let as_rc = Rc::new(ir_parameter);
builder.parameters_mut().push(as_rc.clone());
parameter_symbol.borrow_mut().set_ir_parameter(as_rc);
builder.push_parameter(&parameter_symbol, as_rc.clone());
}
}
/// If `class_context.is_some()`, set parameter 0 to the self parameter/variable on the builder.
fn handle_method_case(
&self,
builder: &mut IrBuilder,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
) {
fn handle_method_case(&self, builder: &mut IrBuilder, class_context: Option<&ClassSymbol>) {
// if we are a method, we need to set the self parameter on the builder
if class_context.is_some() {
let parameter_0 = builder.parameters()[0].clone();
@ -370,24 +256,39 @@ impl Function {
}
/// Convert all statements to ir.
fn statements_to_ir(&self, builder: &mut IrBuilder, symbol_table: &SymbolTable) {
let return_type_info = self.get_return_type_info();
fn statements_to_ir(
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
function_symbol: &FunctionSymbol,
) {
let return_type_info = Self::get_return_type_info(types_table, function_symbol);
let should_return_value = !matches!(return_type_info, TypeInfo::Void);
for (i, statement) in self.statements.iter().enumerate() {
let is_last = i == self.statements.len() - 1;
statement.to_ir(builder, symbol_table, should_return_value && is_last);
statement.to_ir(
builder,
symbol_table,
types_table,
should_return_value && is_last,
);
}
}
pub fn to_ir(
&self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
types_table: &TypesTable,
class_context: Option<&ClassSymbol>,
) -> IrFunction {
let mut builder = IrBuilder::new();
let function_symbol = symbol_table
.get_function_symbol(self.scope_id.unwrap(), self.declared_name())
.unwrap();
// parameters
self.parameters_to_ir(&mut builder);
self.parameters_to_ir(&mut builder, symbol_table, types_table);
let entry_block_id = builder.new_block();
@ -395,15 +296,15 @@ impl Function {
self.handle_method_case(&mut builder, class_context);
// body
self.statements_to_ir(&mut builder, symbol_table);
self.statements_to_ir(&mut builder, symbol_table, types_table, function_symbol);
builder.finish_block();
let entry_block = builder.get_block(entry_block_id).clone();
IrFunction::new(
fqn_parts_to_string(self.function_symbol.as_ref().unwrap().borrow().fqn_parts()),
builder.parameters(),
&self.get_return_type_info(),
fqn_parts_to_string(function_symbol.fqn_parts()),
builder.parameters().iter().map(|p| (*p).clone()).collect(),
&Self::get_return_type_info(types_table, function_symbol),
entry_block,
)
}

99
dmc-lib/src/ast/generic_parameter.rs
View File

@ -1,11 +1,9 @@
use crate::ast::type_use::TypeUse;
use crate::diagnostic::{Diagnostic, SecondaryLabel};
use crate::error_codes::SYMBOL_ALREADY_DECLARED;
use crate::diagnostic::Diagnostic;
use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::generic_parameter_symbol::GenericParameterSymbol;
use crate::symbol_table::{SymbolInsertError, SymbolTable};
use crate::{diagnostics_result, handle_diagnostics, maybe_return_diagnostics};
use crate::symbol_table::SymbolTable;
use crate::{diagnostics_result, handle_diagnostics};
use std::cell::RefCell;
use std::rc::Rc;
@ -13,6 +11,7 @@ pub struct GenericParameter {
declared_name: Rc<str>,
declared_name_source_range: SourceRange,
extends: Vec<TypeUse>,
scope_id: Option<usize>,
generic_parameter_symbol: Option<Rc<RefCell<GenericParameterSymbol>>>,
}
@ -26,87 +25,31 @@ impl GenericParameter {
declared_name: declared_name.into(),
declared_name_source_range,
extends,
scope_id: None,
generic_parameter_symbol: None,
}
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
) -> Result<Rc<RefCell<GenericParameterSymbol>>, Vec<Diagnostic>> {
// insert symbol
let to_insert =
GenericParameterSymbol::new(&self.declared_name, &self.declared_name_source_range);
let to_return = match symbol_table.insert_generic_parameter_symbol(to_insert) {
Ok(generic_parameter_symbol) => generic_parameter_symbol,
Err(symbol_insert_error) => {
return match symbol_insert_error {
SymbolInsertError::AlreadyDeclared(already_declared) => {
let already_declared_symbol = already_declared.symbol().borrow();
let already_declared_source_range =
already_declared_symbol.declared_name_source_range();
let diagnostic = Diagnostic::new(
&format!("Symbol {} already declared in scope.", self.declared_name),
self.declared_name_source_range.start(),
self.declared_name_source_range.end(),
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.scope_id = Some(container_scope);
for type_use in &mut self.extends {
type_use.init_scopes(symbol_table, container_scope);
}
}
pub fn make_symbol(&self) -> GenericParameterSymbol {
GenericParameterSymbol::new(
&self.declared_name,
&self.declared_name_source_range,
self.scope_id.unwrap(),
)
.with_reporter(file!(), line!())
.with_error_code(SYMBOL_ALREADY_DECLARED)
.with_secondary_labels(&[SecondaryLabel::new(
already_declared_source_range.start(),
already_declared_source_range.end(),
Some("Symbol already declared here.".to_string()),
)]);
Err(vec![diagnostic])
}
};
}
};
// save param symbol
self.generic_parameter_symbol = Some(to_return.clone());
let mut diagnostics: Vec<Diagnostic> = vec![];
for type_use in &mut self.extends {
handle_diagnostics!(type_use.gather_declared_names(symbol_table), diagnostics);
}
if diagnostics.is_empty() {
Ok(to_return)
} else {
Err(diagnostics)
}
}
pub fn check_name_usages(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
// check the extends type uses
for type_use in &mut self.extends {
handle_diagnostics!(
type_use.check_name_usages(symbol_table, class_context),
diagnostics
);
}
maybe_return_diagnostics!(diagnostics);
// now that each extends type use has type info, set the type infos on the generic parameter
let extends_type_infos = self
.extends
pub fn check_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
self.extends
.iter()
.map(|type_use| type_use.type_info().clone())
.collect::<Vec<_>>();
self.generic_parameter_symbol
.as_mut()
.unwrap()
.borrow_mut()
.set_extends(extends_type_infos);
Ok(())
.flat_map(|type_use| type_use.check_names(symbol_table))
.collect()
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {

77
dmc-lib/src/ast/helpers.rs
View File

@ -1,9 +1,11 @@
use crate::ast::diagnostic_factories::symbol_already_declared;
use crate::ast::fqn_context::FqnContext;
use crate::diagnostic::{Diagnostic, SecondaryLabel};
use crate::ast::parameter::Parameter;
use crate::diagnostic::Diagnostic;
use crate::diagnostics_result;
use crate::error_codes::SYMBOL_ALREADY_DECLARED;
use crate::source_range::SourceRange;
use crate::symbol_table::SymbolInsertError;
use crate::symbol::Symbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol_table::SymbolTable;
use std::rc::Rc;
/// Iterates through all `ts`, running the `f` function, and pushing returned `Diagnostic`s
@ -72,36 +74,6 @@ pub fn collect_diagnostics_single<T>(
diagnostics_result!(diagnostics)
}
pub fn map_symbol_insert_result<T>(
insert_result: Result<T, SymbolInsertError>,
declared_name_source_range: &SourceRange,
) -> Result<T, Vec<Diagnostic>> {
match insert_result {
Ok(symbol) => Ok(symbol),
Err(symbol_insert_error) => match symbol_insert_error {
SymbolInsertError::AlreadyDeclared(already_declared) => {
let already_declared_symbol = already_declared.symbol().borrow();
let diagnostic = Diagnostic::new(
&format!(
"Symbol {} already declared in current scope.",
already_declared_symbol.declared_name()
),
declared_name_source_range.start(),
declared_name_source_range.end(),
)
.with_reporter(file!(), line!())
.with_error_code(SYMBOL_ALREADY_DECLARED)
.with_secondary_labels(&[SecondaryLabel::new(
already_declared_symbol.declared_name_source_range().start(),
already_declared_symbol.declared_name_source_range().end(),
Some("Symbol already declared here.".to_string()),
)]);
Err(vec![diagnostic])
}
},
}
}
pub fn gather_oks<T, R>(
ts: &mut [T],
mut f: impl FnMut(&mut T) -> Result<R, Vec<Diagnostic>>,
@ -122,3 +94,40 @@ pub fn gather_oks<T, R>(
pub fn resolve_ctor_name(fqn_context: &FqnContext) -> Vec<Rc<str>> {
fqn_context.resolve("ctor") // ctor is a keyword at the language level, should not be callable via normal means
}
pub fn try_insert_symbol_into(
symbol: Symbol,
symbol_table: &mut SymbolTable,
) -> Result<(), Diagnostic> {
let maybe_already_inserted = symbol_table.get_symbol(symbol.scope_id(), symbol.declared_name());
if let Some(already_inserted) = maybe_already_inserted {
Err(symbol_already_declared(&already_inserted, &symbol))
} else {
symbol_table.insert_symbol(symbol);
Ok(())
}
}
pub fn try_insert_symbols_into(
symbols: Vec<Symbol>,
symbol_table: &mut SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
let diagnostics: Vec<Diagnostic> = symbols
.into_iter()
.map(|symbol| try_insert_symbol_into(symbol, symbol_table))
.filter_map(Result::err)
.collect();
diagnostics_result!(diagnostics)
}
pub fn collect_parameter_symbols_into(
parameters: &[Parameter],
all_symbols: &mut Vec<Symbol>,
parameter_symbols: &mut Vec<Rc<ParameterSymbol>>,
) {
for parameter in parameters {
let symbol = Rc::new(parameter.make_symbol());
all_symbols.push(Symbol::Parameter(symbol.clone()));
parameter_symbols.push(symbol);
}
}

270
dmc-lib/src/ast/identifier.rs
View File

@ -1,25 +1,39 @@
use crate::ast::diagnostic_factories::{
outer_class_field_usage, outer_class_method_usage, self_constructor_used_in_init,
self_field_used_in_init, self_method_used_in_init, symbol_not_found,
};
use crate::ast::ir_builder::IrBuilder;
use crate::ast::ir_util::get_or_init_field_pointer_variable;
use crate::diagnostic::Diagnostic;
use crate::ir::ir_assign::IrAssign;
use crate::ir::ir_expression::IrExpression;
use crate::ir::ir_operation::IrOperation;
use crate::ir::ir_read_field::IrReadField;
use crate::ir::ir_statement::IrStatement;
use crate::ir::ir_variable::IrVariable;
use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::expressible_symbol::ExpressibleSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;
use std::cell::RefCell;
use std::rc::Rc;
pub struct Identifier {
name: String,
scope_id: Option<usize>,
expressible_symbol: Option<ExpressibleSymbol>,
type_info: Option<TypeInfo>,
source_range: SourceRange,
scope_id: Option<usize>,
}
impl Identifier {
pub fn new(name: &str, source_range: SourceRange) -> Self {
Self {
name: name.into(),
scope_id: None,
expressible_symbol: None,
type_info: None,
source_range,
scope_id: None,
}
}
@ -27,45 +41,237 @@ impl Identifier {
&self.name
}
pub fn gather_declared_names(
&mut self,
pub fn init_scope_id(&mut self, container_scope: usize) {
self.scope_id = Some(container_scope);
}
pub fn scope_id(&self) -> usize {
self.scope_id.unwrap()
}
/// Check against recursively constructing this class.
fn check_self_constructor_use(
&self,
context_class_symbol: &ClassSymbol,
class_symbol: &ClassSymbol,
) -> Option<Diagnostic> {
// this is not future-proof, as we will eventually allow reference to the self class, which
// would (theoretically) be assigned to an instance field
if context_class_symbol == class_symbol {
Some(self_constructor_used_in_init(&self.source_range))
} else {
None
}
}
/// Check against using this or outer class' bare fields.
fn check_self_or_outer_field_use(
&self,
context_class_symbol: &ClassSymbol,
field_symbol: &FieldSymbol,
) -> Option<Diagnostic> {
// Usage of a bare field will always be an error, whether in this class or an outer class
if context_class_symbol
.fields()
.contains_key(field_symbol.declared_name())
{
Some(self_field_used_in_init(&self.source_range))
} else {
Some(outer_class_field_usage(&self.source_range))
}
}
/// Check against using self or outer class methods.
fn check_self_or_outer_method_use(
&self,
context_class_symbol: &ClassSymbol,
function_symbol: &FunctionSymbol,
) -> Option<Diagnostic> {
if context_class_symbol
.functions()
.contains_key(function_symbol.declared_name())
{
// Can only use Self static functions, which we don't have yet
Some(self_method_used_in_init(&self.source_range))
} else if function_symbol.is_method() {
// Can only use outer class static functions, which we don't have yet
Some(outer_class_method_usage(&self.source_range))
} else {
None
}
}
pub fn check_name_as_field_initializer(
&self,
symbol_table: &SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
self.scope_id = Some(symbol_table.current_scope_id());
Ok(())
context_class_symbol: &ClassSymbol,
) -> Option<Diagnostic> {
let symbol = symbol_table.find_expressible_symbol(self.scope_id.unwrap(), &self.name);
if let Some(symbol) = symbol {
match symbol {
ExpressibleSymbol::Class(class_symbol) => {
self.check_self_constructor_use(context_class_symbol, &class_symbol)
}
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
let maybe_expressible_symbol =
symbol_table.find_expressible_symbol(self.scope_id.unwrap(), &self.name);
match maybe_expressible_symbol {
None => Err(vec![Diagnostic::new(
&format!("Unable to resolve symbol {}", self.name),
self.source_range.start(),
self.source_range.end(),
)]),
Some(expressible_symbol) => {
self.expressible_symbol = Some(expressible_symbol);
Ok(())
ExpressibleSymbol::Field(field_symbol) => {
self.check_self_or_outer_field_use(context_class_symbol, &field_symbol)
}
ExpressibleSymbol::Function(function_symbol) => {
self.check_self_or_outer_method_use(context_class_symbol, &function_symbol)
}
ExpressibleSymbol::Parameter(_) => {
// Cannot get here, because classes cannot currently be declared in functions
unreachable!()
}
ExpressibleSymbol::Variable(_) => {
// Cannot get here, as classes cannot currently be declared in functions
unreachable!()
}
}
} else {
Some(symbol_not_found(&self.name, &self.source_range))
}
}
pub fn type_check(&mut self, _symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
let type_info = self.expressible_symbol.as_ref().unwrap().type_info();
self.type_info = Some(type_info);
Ok(())
pub fn check_constructor_local_name(
&self,
symbol_table: &SymbolTable,
context_class_symbol: &ClassSymbol,
) -> Option<Diagnostic> {
let symbol = symbol_table.find_expressible_symbol(self.scope_id.unwrap(), &self.name);
if let Some(symbol) = symbol {
match symbol {
ExpressibleSymbol::Class(class_symbol) => {
self.check_self_constructor_use(context_class_symbol, &class_symbol)
}
ExpressibleSymbol::Field(field_symbol) => {
self.check_self_or_outer_field_use(context_class_symbol, &field_symbol)
}
ExpressibleSymbol::Function(function_symbol) => {
self.check_self_or_outer_method_use(context_class_symbol, &function_symbol)
}
ExpressibleSymbol::Parameter(_) => None,
ExpressibleSymbol::Variable(_) => None,
}
} else {
Some(symbol_not_found(&self.name, &self.source_range))
}
}
pub fn type_info(&self) -> &TypeInfo {
self.type_info.as_ref().unwrap()
pub fn check_method_local_name(
&self,
symbol_table: &SymbolTable,
context_class_symbol: &ClassSymbol,
) -> Option<Diagnostic> {
let symbol = symbol_table.find_expressible_symbol(self.scope_id.unwrap(), &self.name);
if let Some(symbol) = symbol {
match symbol {
ExpressibleSymbol::Class(_) => {
None // all class usages should be ok
}
ExpressibleSymbol::Field(field_symbol) => {
// Must be a reference to a field in this class
if context_class_symbol
.fields()
.contains_key(field_symbol.declared_name())
{
None
} else {
Some(outer_class_field_usage(&self.source_range))
}
}
ExpressibleSymbol::Function(function_symbol) => {
// Must be a method in this class
if function_symbol.is_method()
&& !context_class_symbol
.functions()
.contains_key(function_symbol.declared_name())
{
Some(outer_class_method_usage(&self.source_range))
} else {
None
}
}
ExpressibleSymbol::Parameter(_) => {
None // ok
}
ExpressibleSymbol::Variable(_) => {
None // ok
}
}
} else {
Some(symbol_not_found(&self.name, &self.source_range))
}
}
pub fn expressible_symbol(&self) -> &ExpressibleSymbol {
self.expressible_symbol.as_ref().unwrap()
/// WARNING: this is not appropriate (yet) for class static functions.
pub fn check_static_fn_local_name(&self, symbol_table: &SymbolTable) -> Option<Diagnostic> {
if symbol_table
.find_expressible_symbol(self.scope_id.unwrap(), &self.name)
.is_some()
{
None
} else {
Some(symbol_not_found(&self.name, &self.source_range))
}
}
pub fn source_range(&self) -> &SourceRange {
&self.source_range
}
pub fn type_info<'a>(
&self,
symbol_table: &SymbolTable,
types_table: &'a TypesTable,
) -> &'a TypeInfo {
let variable_symbol = symbol_table
.get_variable_symbol(self.scope_id.unwrap(), &self.name)
.unwrap();
types_table.variable_types().get(variable_symbol).unwrap()
}
pub fn ir_expression(
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
) -> IrExpression {
let expressible_symbol = symbol_table
.find_expressible_symbol(self.scope_id.unwrap(), &self.name)
.unwrap();
match expressible_symbol {
ExpressibleSymbol::Class(class_symbol) => {
todo!()
}
ExpressibleSymbol::Field(field_symbol) => {
let read_destination = IrVariable::new_vr(
builder.new_t_var().into(),
builder.current_block().id(),
field_symbol.type_info(),
);
let read_destination_as_rc = Rc::new(RefCell::new(read_destination));
let ir_read_field = IrReadField::new(
get_or_init_field_pointer_variable(builder, &field_symbol).clone(),
);
builder
.current_block_mut()
.add_statement(IrStatement::Assign(IrAssign::new(
read_destination_as_rc.clone(),
IrOperation::ReadField(ir_read_field),
)));
IrExpression::Variable(read_destination_as_rc)
}
ExpressibleSymbol::Function(_) => {
panic!("Cannot yet get ir-variable for FunctionSymbol")
}
ExpressibleSymbol::Parameter(parameter_symbol) => {
let parameters_map = builder.parameters_map();
let ir_parameter = parameters_map.get(&parameter_symbol).unwrap();
IrExpression::Parameter(ir_parameter.clone())
}
ExpressibleSymbol::Variable(variable_symbol) => {
let ir_variable = builder.local_variables().get(&variable_symbol).unwrap();
IrExpression::Variable(ir_variable.clone())
}
}
}
}

39
dmc-lib/src/ast/ir_builder.rs
View File

@ -3,12 +3,15 @@ use crate::ir::ir_parameter::IrParameter;
use crate::ir::ir_parameter_or_variable::IrParameterOrVariable;
use crate::ir::ir_statement::IrStatement;
use crate::ir::ir_variable::IrVariable;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol::variable_symbol::VariableSymbol;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
pub struct IrBuilder {
parameters: Vec<Rc<IrParameter>>,
parameters: Vec<(Rc<ParameterSymbol>, Rc<IrParameter>)>,
local_variables: HashMap<Rc<VariableSymbol>, Rc<RefCell<IrVariable>>>,
block_counter: usize,
t_var_counter: usize,
blocks: HashMap<usize, Rc<RefCell<IrBlock>>>,
@ -22,6 +25,7 @@ impl IrBuilder {
pub fn new() -> Self {
Self {
parameters: vec![],
local_variables: HashMap::new(),
block_counter: 0,
t_var_counter: 0,
blocks: HashMap::new(),
@ -32,12 +36,37 @@ impl IrBuilder {
}
}
pub fn parameters(&self) -> &[Rc<IrParameter>] {
&self.parameters
pub fn local_variables(&self) -> &HashMap<Rc<VariableSymbol>, Rc<RefCell<IrVariable>>> {
&self.local_variables
}
pub fn parameters_mut(&mut self) -> &mut Vec<Rc<IrParameter>> {
&mut self.parameters
pub fn local_variables_mut(
&mut self,
) -> &mut HashMap<Rc<VariableSymbol>, Rc<RefCell<IrVariable>>> {
&mut self.local_variables
}
pub fn parameters(&self) -> Vec<&Rc<IrParameter>> {
self.parameters
.iter()
.map(|(_, ir_parameter)| ir_parameter)
.collect()
}
pub fn parameters_map(&self) -> HashMap<Rc<ParameterSymbol>, Rc<IrParameter>> {
let mut map = HashMap::new();
for (name, ir_parameter) in &self.parameters {
map.insert(name.clone(), ir_parameter.clone());
}
map
}
pub fn push_parameter(
&mut self,
parameter_symbol: &Rc<ParameterSymbol>,
parameter: Rc<IrParameter>,
) {
self.parameters.push((parameter_symbol.clone(), parameter));
}
pub fn new_block(&mut self) -> usize {

25
dmc-lib/src/ast/ir_util.rs
View File

@ -5,25 +5,24 @@ use crate::ir::ir_get_field_ref_mut::IrGetFieldRefMut;
use crate::ir::ir_operation::IrOperation;
use crate::ir::ir_statement::IrStatement;
use crate::ir::ir_variable::IrVariable;
use crate::symbol::Symbol;
use crate::symbol::field_symbol::FieldSymbol;
use std::cell::RefCell;
use std::rc::Rc;
pub fn get_or_init_field_pointer_variable<'a>(
builder: &'a mut IrBuilder,
field_symbol: &Rc<RefCell<FieldSymbol>>,
field_symbol: &Rc<FieldSymbol>,
) -> &'a Rc<RefCell<IrVariable>> {
// This following should work because blocks are flat in the ir; if a variable is defined in the
// ir block from this point forward, it's available to all subsequent blocks.
if !builder
.field_pointer_variables()
.contains_key(field_symbol.borrow().declared_name())
.contains_key(field_symbol.declared_name())
{
let field_ref_variable = IrVariable::new_vr(
builder.new_t_var().into(),
builder.current_block().id(),
field_symbol.borrow().type_info(),
field_symbol.type_info(),
);
let as_rc = Rc::new(RefCell::new(field_ref_variable));
let to_insert = as_rc.clone();
@ -34,31 +33,31 @@ pub fn get_or_init_field_pointer_variable<'a>(
as_rc,
IrOperation::GetFieldRef(IrGetFieldRef::new(
self_parameter_or_variable.clone(),
field_symbol.borrow().field_index(),
field_symbol.field_index(),
)),
)));
builder
.field_pointer_variables_mut()
.insert(field_symbol.borrow().declared_name_owned(), to_insert);
.insert(field_symbol.declared_name_owned(), to_insert);
}
builder
.field_pointer_variables()
.get(field_symbol.borrow().declared_name())
.get(field_symbol.declared_name())
.unwrap()
}
pub fn get_or_init_mut_field_pointer_variable<'a>(
builder: &'a mut IrBuilder,
field_symbol: &Rc<RefCell<FieldSymbol>>,
field_symbol: &Rc<FieldSymbol>,
) -> &'a Rc<RefCell<IrVariable>> {
if !builder
.field_mut_pointer_variables()
.contains_key(field_symbol.borrow().declared_name())
.contains_key(field_symbol.declared_name())
{
let mut_field_pointer_variable = IrVariable::new_vr(
builder.new_t_var().into(),
builder.current_block().id(),
field_symbol.borrow().type_info(),
field_symbol.type_info(),
);
let as_rc = Rc::new(RefCell::new(mut_field_pointer_variable));
let to_insert = as_rc.clone();
@ -69,15 +68,15 @@ pub fn get_or_init_mut_field_pointer_variable<'a>(
as_rc,
IrOperation::GetFieldRefMut(IrGetFieldRefMut::new(
self_parameter_or_variable.clone(),
field_symbol.borrow().field_index(),
field_symbol.field_index(),
)),
)));
builder
.field_mut_pointer_variables_mut()
.insert(field_symbol.borrow().declared_name_owned(), to_insert);
.insert(field_symbol.declared_name_owned(), to_insert);
}
builder
.field_mut_pointer_variables()
.get(field_symbol.borrow().declared_name())
.get(field_symbol.declared_name())
.unwrap()
}

155
dmc-lib/src/ast/let_statement.rs
View File

@ -1,12 +1,16 @@
use crate::ast::expression::Expression;
use crate::ast::helpers::try_insert_symbol_into;
use crate::ast::ir_builder::IrBuilder;
use crate::diagnostic::Diagnostic;
use crate::ir::ir_assign::IrAssign;
use crate::ir::ir_statement::IrStatement;
use crate::ir::ir_variable::IrVariable;
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::variable_symbol::VariableSymbol;
use crate::symbol_table::{SymbolInsertError, SymbolTable};
use crate::symbol_table::SymbolTable;
use crate::types_table::TypesTable;
use std::cell::RefCell;
use std::rc::Rc;
@ -46,76 +50,125 @@ impl LetStatement {
&mut self.initializer
}
pub fn gather_declared_names(
&mut self,
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.scope_id = Some(container_scope);
self.initializer.init_scopes(symbol_table, container_scope);
}
fn make_and_insert_variable_symbol(
&self,
symbol_table: &mut SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics = vec![];
match self.initializer_mut().gather_declared_names(symbol_table) {
Ok(_) => {}
Err(mut initializer_diagnostics) => {
diagnostics.append(&mut initializer_diagnostics);
}
}
let insert_result = symbol_table.insert_variable_symbol(VariableSymbol::new(
) -> Option<Diagnostic> {
let variable_symbol = Rc::new(VariableSymbol::new(
&self.declared_name,
self.declared_name_source_range.clone(),
&self.declared_name_source_range,
self.is_mut,
self.scope_id.unwrap(),
));
if let Err(symbol_insert_error) = insert_result {
match symbol_insert_error {
SymbolInsertError::AlreadyDeclared(already_declared) => {
diagnostics.push(Diagnostic::new(
&format!(
"Symbol {} already declared in current scope",
already_declared.symbol().borrow().declared_name()
),
self.declared_name_source_range.start(),
self.declared_name_source_range.end(),
))
}
}
try_insert_symbol_into(Symbol::Variable(variable_symbol), symbol_table).err()
}
self.scope_id = Some(symbol_table.current_scope_id());
if diagnostics.is_empty() {
Ok(())
} else {
Err(diagnostics)
}
pub fn analyze_constructor_local_names(
&self,
symbol_table: &mut SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
let mut diagnostics = Vec::new();
diagnostics.append(
&mut self
.initializer
.check_constructor_local_names(symbol_table, class_symbol),
);
if let Some(diagnostic) = self.make_and_insert_variable_symbol(symbol_table) {
diagnostics.push(diagnostic);
}
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
self.initializer.check_name_usages(symbol_table)
diagnostics
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
self.initializer.type_check(symbol_table)?;
let initializer_type_info = self.initializer.type_info();
let variable_symbol =
symbol_table.get_variable_symbol(self.scope_id.unwrap(), &self.declared_name);
variable_symbol
.borrow_mut()
.set_type_info(initializer_type_info.clone());
pub fn analyze_method_local_names(
&self,
symbol_table: &mut SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
let mut diagnostics = Vec::new();
diagnostics.append(
&mut self
.initializer
.check_method_local_names(symbol_table, class_symbol),
);
if let Some(diagnostic) = self.make_and_insert_variable_symbol(symbol_table) {
diagnostics.push(diagnostic);
}
diagnostics
}
pub fn analyze_static_fn_local_names(&self, symbol_table: &mut SymbolTable) -> Vec<Diagnostic> {
let mut diagnostics = Vec::new();
diagnostics.append(&mut self.initializer.check_static_fn_local_names(symbol_table));
if let Some(diagnostic) = self.make_and_insert_variable_symbol(symbol_table) {
diagnostics.push(diagnostic);
}
diagnostics
}
pub fn gather_local_type(&self, symbol_table: &SymbolTable, types_table: &mut TypesTable) {
let initializer_type_info = self
.initializer
.type_info(symbol_table, types_table)
.clone();
let variable_symbol = symbol_table
.get_variable_symbol_owned(self.scope_id.unwrap(), &self.declared_name)
.unwrap();
types_table
.variable_types_mut()
.insert(variable_symbol, initializer_type_info);
}
pub fn type_check(
&mut self,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> Result<(), Vec<Diagnostic>> {
self.initializer.type_check(symbol_table, types_table)?;
let initializer_type_info = self.initializer.type_info(symbol_table, types_table);
let variable_symbol = symbol_table
.get_variable_symbol_owned(self.scope_id.unwrap(), &self.declared_name)
.unwrap();
Ok(())
}
pub fn to_ir(&self, builder: &mut IrBuilder, symbol_table: &SymbolTable) {
let init_operation = self.initializer.to_ir_operation(builder, symbol_table);
pub fn to_ir(
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) {
let init_operation = self
.initializer
.to_ir_operation(builder, symbol_table, types_table);
let destination_symbol = symbol_table
.get_variable_symbol_owned(self.scope_id.unwrap(), &self.declared_name)
.unwrap();
let destination_type = types_table
.variable_types()
.get(&destination_symbol)
.unwrap();
let destination_symbol =
symbol_table.get_variable_symbol(self.scope_id.unwrap(), &self.declared_name);
let destination_vr_variable = IrVariable::new_vr(
self.declared_name().into(),
builder.current_block().id(),
self.initializer.type_info(),
destination_type,
);
let as_rc = Rc::new(RefCell::new(destination_vr_variable));
let ir_assign = IrAssign::new(as_rc.clone(), init_operation);
destination_symbol.borrow_mut().set_vr_variable(as_rc);
builder
.local_variables_mut()
.insert(destination_symbol, as_rc.clone());
builder
.current_block_mut()

1
dmc-lib/src/ast/mod.rs
View File

@ -4,6 +4,7 @@ pub mod call;
pub mod class;
pub mod compilation_unit;
pub mod constructor;
mod diagnostic_factories;
pub mod double_literal;
pub mod expression;
pub mod expression_statement;

63
dmc-lib/src/ast/negative_expression.rs
View File

@ -8,8 +8,10 @@ use crate::ir::ir_operation::IrOperation;
use crate::ir::ir_statement::IrStatement;
use crate::ir::ir_variable::IrVariable;
use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;
use std::cell::RefCell;
use std::rc::Rc;
@ -40,21 +42,49 @@ impl NegativeExpression {
&mut self.operand
}
pub fn gather_declared_names(
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.operand.init_scopes(symbol_table, container_scope);
}
pub fn check_field_initializer_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
self.operand
.check_field_initializer_names(symbol_table, class_symbol)
}
pub fn check_constructor_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
self.operand
.check_constructor_local_names(symbol_table, class_symbol)
}
pub fn check_method_local_names(
&self,
symbol_table: &SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
self.operand
.check_method_local_names(symbol_table, class_symbol)
}
pub fn check_static_fn_local_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
self.operand.check_static_fn_local_names(symbol_table)
}
pub fn type_check(
&mut self,
symbol_table: &mut SymbolTable,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> Result<(), Vec<Diagnostic>> {
self.operand.gather_declared_names(symbol_table)
}
self.operand.type_check(symbol_table, types_table)?;
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
self.operand.check_name_usages(symbol_table)
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
self.operand.type_check(symbol_table)?;
let type_info = self.operand.type_info();
let type_info = self.operand.type_info(symbol_table, types_table);
if type_info.can_negate() {
self.type_info = Some(type_info.negate_result());
Ok(())
@ -67,10 +97,15 @@ impl NegativeExpression {
}
}
pub fn to_ir(&self, builder: &mut IrBuilder, symbol_table: &SymbolTable) -> IrExpression {
pub fn to_ir(
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
) -> IrExpression {
let operand_as_ir = self
.operand
.to_ir_expression(builder, symbol_table)
.to_ir_expression(builder, symbol_table, types_table)
.expect("Attempt to negate non-value expression");
match operand_as_ir {

80
dmc-lib/src/ast/parameter.rs
View File

@ -1,17 +1,15 @@
use crate::ast::type_use::TypeUse;
use crate::diagnostic::Diagnostic;
use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol_table::{SymbolInsertError, SymbolTable};
use std::cell::RefCell;
use crate::symbol_table::SymbolTable;
use std::rc::Rc;
pub struct Parameter {
declared_name: Rc<str>,
declared_name_source_range: SourceRange,
type_use: TypeUse,
parameter_symbol: Option<Rc<RefCell<ParameterSymbol>>>,
scope_id: Option<usize>,
}
impl Parameter {
@ -24,71 +22,37 @@ impl Parameter {
declared_name: declared_name.into(),
declared_name_source_range,
type_use,
parameter_symbol: None,
scope_id: None,
}
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
) -> Result<Rc<RefCell<ParameterSymbol>>, Vec<Diagnostic>> {
// insert parameter symbol
let insert_result = symbol_table.insert_parameter_symbol(ParameterSymbol::new(
pub fn declared_name(&self) -> &str {
&self.declared_name
}
pub fn scope_id(&self) -> usize {
self.scope_id.unwrap()
}
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.scope_id = Some(container_scope);
self.type_use.init_scopes(symbol_table, container_scope);
}
pub fn make_symbol(&self) -> ParameterSymbol {
ParameterSymbol::new(
&self.declared_name,
self.declared_name_source_range.clone(),
));
match insert_result {
Ok(parameter_symbol) => {
self.parameter_symbol = Some(parameter_symbol.clone());
}
Err(symbol_insert_error) => {
return match symbol_insert_error {
SymbolInsertError::AlreadyDeclared(already_declared) => {
Err(vec![Diagnostic::new(
&format!(
"Parameter {} already declared.",
already_declared.symbol().borrow().declared_name()
),
self.declared_name_source_range.start(),
self.declared_name_source_range.end(),
)])
}
};
}
self.scope_id.unwrap(),
)
}
// type use
self.type_use.gather_declared_names(symbol_table)?;
Ok(self.parameter_symbol.clone().unwrap())
}
pub fn check_name_usages(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
) -> Result<(), Vec<Diagnostic>> {
// check the type use
self.type_use
.check_name_usages(symbol_table, class_context)?;
// set type on parameter symbol
self.parameter_symbol
.as_mut()
.unwrap()
.borrow_mut()
.set_type_info(self.type_use.type_info().clone());
Ok(())
pub fn check_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
self.type_use.check_names(symbol_table)
}
pub fn type_check(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
self.type_use.type_check(symbol_table)?;
Ok(())
}
pub fn parameter_symbol(&self) -> &Rc<RefCell<ParameterSymbol>> {
self.parameter_symbol
.as_ref()
.expect("parameter symbol not initialized")
}
}

81
dmc-lib/src/ast/statement.rs
View File

@ -3,8 +3,10 @@ use crate::ast::expression_statement::ExpressionStatement;
use crate::ast::ir_builder::IrBuilder;
use crate::ast::let_statement::LetStatement;
use crate::diagnostic::Diagnostic;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol_table::SymbolTable;
use crate::type_info::TypeInfo;
use crate::types_table::TypesTable;
pub enum Statement {
Let(LetStatement),
@ -13,42 +15,84 @@ pub enum Statement {
}
impl Statement {
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
) -> Result<(), Vec<Diagnostic>> {
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
match self {
Statement::Let(let_statement) => let_statement.gather_declared_names(symbol_table),
Statement::Let(let_statement) => {
let_statement.init_scopes(symbol_table, container_scope);
}
Statement::Expression(expression_statement) => {
expression_statement.gather_declared_names(symbol_table)
expression_statement.init_scopes(symbol_table, container_scope);
}
Statement::Assign(assign_statement) => {
assign_statement.gather_declared_names(symbol_table)
assign_statement.init_scopes(symbol_table, container_scope);
}
}
}
pub fn check_name_usages(&mut self, symbol_table: &SymbolTable) -> Result<(), Vec<Diagnostic>> {
pub fn analyze_constructor_local_names(
&self,
symbol_table: &mut SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
match self {
Statement::Let(let_statement) => let_statement.check_name_usages(symbol_table),
Statement::Expression(expression_statement) => {
expression_statement.check_name_usages(symbol_table)
Statement::Let(let_statement) => {
let_statement.analyze_constructor_local_names(symbol_table, class_symbol)
}
Statement::Expression(expression_statement) => {
expression_statement.check_constructor_local_names(symbol_table, class_symbol)
}
Statement::Assign(assign_statement) => {
assign_statement.check_constructor_local_names(symbol_table, class_symbol)
}
}
}
pub fn analyze_method_local_names(
&self,
symbol_table: &mut SymbolTable,
class_symbol: &ClassSymbol,
) -> Vec<Diagnostic> {
match self {
Statement::Let(let_statement) => {
let_statement.analyze_method_local_names(symbol_table, class_symbol)
}
Statement::Expression(expression_statement) => {
expression_statement.check_method_local_names(symbol_table, class_symbol)
}
Statement::Assign(assign_statement) => {
assign_statement.check_method_local_names(symbol_table, class_symbol)
}
}
}
pub fn analyze_static_fn_local_names(&self, symbol_table: &mut SymbolTable) -> Vec<Diagnostic> {
match self {
Statement::Let(let_statement) => {
let_statement.analyze_static_fn_local_names(symbol_table)
}
Statement::Expression(expression_statement) => {
expression_statement.check_static_fn_local_names(symbol_table)
}
Statement::Assign(assign_statement) => {
assign_statement.check_static_fn_local_names(symbol_table)
}
Statement::Assign(assign_statement) => assign_statement.check_name_usages(symbol_table),
}
}
pub fn type_check(
&mut self,
symbol_table: &SymbolTable,
types_table: &mut TypesTable,
must_return_type_info: Option<&TypeInfo>,
) -> Result<(), Vec<Diagnostic>> {
match self {
Statement::Let(let_statement) => let_statement.type_check(symbol_table),
Statement::Let(let_statement) => let_statement.type_check(symbol_table, types_table),
Statement::Expression(expression_statement) => {
expression_statement.type_check(symbol_table, must_return_type_info)
expression_statement.type_check(symbol_table, types_table, must_return_type_info)
}
Statement::Assign(assign_statement) => {
assign_statement.type_check(symbol_table, types_table)
}
Statement::Assign(assign_statement) => assign_statement.type_check(symbol_table),
}
}
@ -56,17 +100,18 @@ impl Statement {
&self,
builder: &mut IrBuilder,
symbol_table: &SymbolTable,
types_table: &TypesTable,
should_return_value: bool,
) {
match self {
Statement::Let(let_statement) => {
let_statement.to_ir(builder, symbol_table);
let_statement.to_ir(builder, symbol_table, types_table);
}
Statement::Expression(expression_statement) => {
expression_statement.to_ir(builder, symbol_table, should_return_value);
expression_statement.to_ir(builder, symbol_table, types_table, should_return_value);
}
Statement::Assign(assign_statement) => {
assign_statement.to_ir(builder, symbol_table);
assign_statement.to_ir(builder, symbol_table, types_table);
}
}
}

47
dmc-lib/src/ast/type_use.rs
View File

@ -1,3 +1,4 @@
use crate::ast::diagnostic_factories::symbol_not_found;
use crate::diagnostic::Diagnostic;
use crate::error_codes::INCORRECT_GENERIC_ARGUMENTS;
use crate::source_range::SourceRange;
@ -9,7 +10,7 @@ use std::cell::RefCell;
use std::rc::Rc;
pub struct TypeUse {
declared_name: String,
declared_name: Rc<str>,
declared_name_source_range: SourceRange,
generic_arguments: Vec<TypeUse>,
scope_id: Option<usize>,
@ -35,6 +36,34 @@ impl TypeUse {
&self.declared_name
}
pub fn init_scopes(&mut self, symbol_table: &mut SymbolTable, container_scope: usize) {
self.scope_id = Some(container_scope);
for type_use in &mut self.generic_arguments {
type_use.init_scopes(symbol_table, container_scope);
}
}
pub fn check_names(&self, symbol_table: &SymbolTable) -> Vec<Diagnostic> {
let mut diagnostics: Vec<Diagnostic> = Vec::new();
// find this name
let maybe_type_symbol =
symbol_table.find_type_symbol(self.scope_id.unwrap(), &self.declared_name);
if maybe_type_symbol.is_none() {
diagnostics.push(symbol_not_found(
self.declared_name(),
&self.declared_name_source_range,
));
}
// check generic args
for type_use in &self.generic_arguments {
type_use.check_names(symbol_table);
}
diagnostics
}
pub fn gather_declared_names(
&mut self,
symbol_table: &mut SymbolTable,
@ -53,7 +82,7 @@ impl TypeUse {
pub fn check_name_usages(
&mut self,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
class_context: Option<&Rc<ClassSymbol>>,
) -> Result<(), Vec<Diagnostic>> {
let mut diagnostics: Vec<Diagnostic> = vec![];
@ -90,8 +119,7 @@ impl TypeUse {
match self.type_info() {
TypeInfo::ClassInstance(class_symbol) => {
// check number of params/args match
let borrowed_class_symbol = class_symbol.borrow();
let generic_parameters = borrowed_class_symbol.generic_parameters();
let generic_parameters = class_symbol.generic_parameters();
if generic_parameters.len() != self.generic_arguments.len() {
let diagnostic = Diagnostic::new(
&format!(
@ -111,7 +139,7 @@ impl TypeUse {
// check that each arg is assignable to the param's extends
for i in 0..self.generic_arguments.len() {
let generic_parameter_symbol = generic_parameters[i].borrow();
let generic_parameter_symbol = &generic_parameters[i];
if generic_parameter_symbol.extends().len() > 0 {
unimplemented!("Generic extends not implemented yet.")
}
@ -153,6 +181,7 @@ mod tests {
use crate::diagnostic::Diagnostic;
use crate::parser::parse_compilation_unit;
use crate::symbol_table::SymbolTable;
use crate::types_table::TypesTable;
#[test]
fn type_check_generics() -> Result<(), Vec<Diagnostic>> {
@ -167,10 +196,12 @@ mod tests {
)?;
let mut symbol_table = SymbolTable::new();
let mut types_table = TypesTable::new();
compilation_unit.gather_declared_names(&mut symbol_table)?;
compilation_unit.check_name_usages(&mut symbol_table)?;
compilation_unit.type_check(&mut symbol_table)?;
compilation_unit.init_scopes(&mut symbol_table);
compilation_unit.gather_symbols_into(&mut symbol_table)?;
compilation_unit.check_names(&mut symbol_table)?;
compilation_unit.type_check(&mut symbol_table, &mut types_table)?;
Ok(())
}

6
dmc-lib/src/error_codes.rs
View File

@ -1,5 +1,6 @@
pub type ErrorCode = usize;
pub const SYMBOL_NOT_FOUND: ErrorCode = 13;
pub const SYMBOL_ALREADY_DECLARED: ErrorCode = 14;
pub const BINARY_INCOMPATIBLE_TYPES: ErrorCode = 15;
pub const ASSIGN_MISMATCHED_TYPES: ErrorCode = 16;
@ -9,3 +10,8 @@ pub const INCORRECT_GENERIC_ARGUMENTS: ErrorCode = 19;
pub const GENERIC_ARGUMENT_TYPE_MISMATCH: ErrorCode = 20;
pub const FIELD_MULTIPLE_INIT: ErrorCode = 21;
pub const FIELD_UNINIT: ErrorCode = 22;
pub const SELF_FIELD_USED_IN_INIT: ErrorCode = 23;
pub const SELF_METHOD_USED_IN_INIT: ErrorCode = 24;
pub const SELF_CONSTRUCTOR_USED_IN_INIT: ErrorCode = 25;
pub const OUTER_CLASS_FIELD_USED_IN_INIT: ErrorCode = 26;
pub const OUTER_CLASS_METHOD_USED_IN_INIT: ErrorCode = 27;

23
dmc-lib/src/ir/ir_block.rs
View File

@ -121,11 +121,13 @@ impl Display for IrBlock {
#[cfg(test)]
mod tests {
use crate::diagnostic::Diagnostic;
use crate::parser::parse_compilation_unit;
use crate::symbol_table::SymbolTable;
use crate::types_table::TypesTable;
#[test]
fn overlapping_assignments_bug_when_k_2() {
fn overlapping_assignments_bug_when_k_2() -> Result<(), Vec<Diagnostic>> {
let mut compilation_unit = parse_compilation_unit(
"
fn main()
@ -138,15 +140,12 @@ mod tests {
)
.unwrap();
let mut symbol_table = SymbolTable::new();
compilation_unit
.gather_declared_names(&mut symbol_table)
.expect("gather failed");
compilation_unit
.check_name_usages(&mut symbol_table)
.expect("name check failed");
compilation_unit
.type_check(&mut symbol_table)
.expect("type check failed");
let mut types_table = TypesTable::new();
compilation_unit.init_scopes(&mut symbol_table);
compilation_unit.gather_symbols_into(&mut symbol_table)?;
compilation_unit.check_names(&mut symbol_table)?;
compilation_unit.type_check(&mut symbol_table, &mut types_table)?;
let main = compilation_unit
.functions()
@ -154,8 +153,10 @@ mod tests {
.find(|f| f.declared_name() == "main")
.unwrap();
let mut main_ir = main.to_ir(&symbol_table, None);
let mut main_ir = main.to_ir(&symbol_table, &types_table, None);
let (register_assignments, _) = main_ir.assign_registers(2);
assert_eq!(register_assignments.len(), 4);
Ok(())
}
}

6
dmc-lib/src/ir/ir_class.rs
View File

@ -51,9 +51,9 @@ impl IrField {
TypeInfo::Integer => VmTypeInfo::Int,
TypeInfo::Double => VmTypeInfo::Double,
TypeInfo::String => VmTypeInfo::String,
TypeInfo::ClassInstance(class_symbol) => VmTypeInfo::ClassInstance(
fqn_parts_to_string(class_symbol.borrow().fqn_parts()).into(),
),
TypeInfo::ClassInstance(class_symbol) => {
VmTypeInfo::ClassInstance(fqn_parts_to_string(class_symbol.fqn_parts()).into())
}
TypeInfo::GenericType(_) => VmTypeInfo::Any,
_ => panic!(),
},

2
dmc-lib/src/ir/ir_function.rs
View File

@ -21,7 +21,7 @@ pub struct IrFunction {
impl IrFunction {
pub fn new(
fqn: Rc<str>,
parameters: &[Rc<IrParameter>],
parameters: Vec<Rc<IrParameter>>,
return_type_info: &TypeInfo,
entry: Rc<RefCell<IrBlock>>,
) -> Self {

3
dmc-lib/src/lib.rs
View File

@ -5,9 +5,10 @@ pub mod error_codes;
pub mod ir;
pub mod lexer;
pub mod parser;
mod scope;
pub mod scope;
pub mod source_range;
pub mod symbol;
pub mod symbol_table;
pub mod token;
pub mod type_info;
pub mod types_table;

7
dmc-lib/src/scope/block_scope.rs
View File

@ -1,12 +1,11 @@
use crate::symbol::variable_symbol::VariableSymbol;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
pub struct BlockScope {
debug_name: String,
parent_id: usize,
variable_symbols: HashMap<Rc<str>, Rc<RefCell<VariableSymbol>>>,
variable_symbols: HashMap<Rc<str>, Rc<VariableSymbol>>,
}
impl BlockScope {
@ -18,11 +17,11 @@ impl BlockScope {
}
}
pub fn variable_symbols(&self) -> &HashMap<Rc<str>, Rc<RefCell<VariableSymbol>>> {
pub fn variable_symbols(&self) -> &HashMap<Rc<str>, Rc<VariableSymbol>> {
&self.variable_symbols
}
pub fn variable_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<RefCell<VariableSymbol>>> {
pub fn variable_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<VariableSymbol>> {
&mut self.variable_symbols
}

64
dmc-lib/src/scope/class_body_scope.rs Normal file
View File

@ -0,0 +1,64 @@
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::constructor_symbol::ConstructorSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use std::collections::HashMap;
use std::rc::Rc;
pub struct ClassBodyScope {
debug_name: String,
parent_id: usize,
class_symbols: HashMap<Rc<str>, Rc<ClassSymbol>>,
field_symbols: HashMap<Rc<str>, Rc<FieldSymbol>>,
function_symbols: HashMap<Rc<str>, Rc<FunctionSymbol>>,
constructor_symbol: Option<Rc<ConstructorSymbol>>,
}
impl ClassBodyScope {
pub fn new(debug_name: &str, parent_id: usize) -> Self {
Self {
debug_name: debug_name.into(),
parent_id,
class_symbols: HashMap::new(),
field_symbols: HashMap::new(),
function_symbols: HashMap::new(),
constructor_symbol: None,
}
}
pub fn class_symbols(&self) -> &HashMap<Rc<str>, Rc<ClassSymbol>> {
&self.class_symbols
}
pub fn class_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<ClassSymbol>> {
&mut self.class_symbols
}
pub fn field_symbols(&self) -> &HashMap<Rc<str>, Rc<FieldSymbol>> {
&self.field_symbols
}
pub fn field_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<FieldSymbol>> {
&mut self.field_symbols
}
pub fn function_symbols(&self) -> &HashMap<Rc<str>, Rc<FunctionSymbol>> {
&self.function_symbols
}
pub fn function_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<FunctionSymbol>> {
&mut self.function_symbols
}
pub fn constructor_symbol(&self) -> Option<&Rc<ConstructorSymbol>> {
self.constructor_symbol.as_ref()
}
pub fn constructor_symbol_mut(&mut self) -> &mut Option<Rc<ConstructorSymbol>> {
&mut self.constructor_symbol
}
pub fn parent_id(&self) -> usize {
self.parent_id
}
}

69
dmc-lib/src/scope/class_scope.rs
View File

@ -1,20 +1,11 @@
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::constructor_symbol::ConstructorSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol::generic_parameter_symbol::GenericParameterSymbol;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
pub struct ClassScope {
debug_name: String,
parent_id: usize,
generic_parameter_symbols: HashMap<Rc<str>, Rc<RefCell<GenericParameterSymbol>>>,
class_symbols: HashMap<Rc<str>, Rc<RefCell<ClassSymbol>>>,
field_symbols: HashMap<Rc<str>, Rc<RefCell<FieldSymbol>>>,
function_symbols: HashMap<Rc<str>, Rc<RefCell<FunctionSymbol>>>,
constructor_symbol: Option<Rc<RefCell<ConstructorSymbol>>>,
generic_parameter_symbols: HashMap<Rc<str>, Rc<GenericParameterSymbol>>,
}
impl ClassScope {
@ -23,58 +14,20 @@ impl ClassScope {
debug_name: debug_name.into(),
parent_id,
generic_parameter_symbols: HashMap::new(),
class_symbols: HashMap::new(),
field_symbols: HashMap::new(),
function_symbols: HashMap::new(),
constructor_symbol: None,
}
}
pub fn generic_parameter_symbols(
&self,
) -> &HashMap<Rc<str>, Rc<RefCell<GenericParameterSymbol>>> {
&self.generic_parameter_symbols
}
pub fn generic_parameter_symbols_mut(
&mut self,
) -> &mut HashMap<Rc<str>, Rc<RefCell<GenericParameterSymbol>>> {
&mut self.generic_parameter_symbols
}
pub fn class_symbols(&self) -> &HashMap<Rc<str>, Rc<RefCell<ClassSymbol>>> {
&self.class_symbols
}
pub fn class_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<RefCell<ClassSymbol>>> {
&mut self.class_symbols
}
pub fn field_symbols(&self) -> &HashMap<Rc<str>, Rc<RefCell<FieldSymbol>>> {
&self.field_symbols
}
pub fn field_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<RefCell<FieldSymbol>>> {
&mut self.field_symbols
}
pub fn function_symbols(&self) -> &HashMap<Rc<str>, Rc<RefCell<FunctionSymbol>>> {
&self.function_symbols
}
pub fn function_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<RefCell<FunctionSymbol>>> {
&mut self.function_symbols
}
pub fn constructor_symbol(&self) -> Option<&Rc<RefCell<ConstructorSymbol>>> {
self.constructor_symbol.as_ref()
}
pub fn constructor_symbol_mut(&mut self) -> &mut Option<Rc<RefCell<ConstructorSymbol>>> {
&mut self.constructor_symbol
}
pub fn parent_id(&self) -> usize {
self.parent_id
}
pub fn generic_parameter_symbols(&self) -> &HashMap<Rc<str>, Rc<GenericParameterSymbol>> {
&self.generic_parameter_symbols
}
pub fn generic_parameter_symbols_mut(
&mut self,
) -> &mut HashMap<Rc<str>, Rc<GenericParameterSymbol>> {
&mut self.generic_parameter_symbols
}
}

7
dmc-lib/src/scope/function_scope.rs
View File

@ -1,12 +1,11 @@
use crate::symbol::parameter_symbol::ParameterSymbol;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
pub struct FunctionScope {
debug_name: String,
parent_id: usize,
parameter_symbols: HashMap<Rc<str>, Rc<RefCell<ParameterSymbol>>>,
parameter_symbols: HashMap<Rc<str>, Rc<ParameterSymbol>>,
}
impl FunctionScope {
@ -18,11 +17,11 @@ impl FunctionScope {
}
}
pub fn parameter_symbols(&self) -> &HashMap<Rc<str>, Rc<RefCell<ParameterSymbol>>> {
pub fn parameter_symbols(&self) -> &HashMap<Rc<str>, Rc<ParameterSymbol>> {
&self.parameter_symbols
}
pub fn parameter_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<RefCell<ParameterSymbol>>> {
pub fn parameter_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<ParameterSymbol>> {
&mut self.parameter_symbols
}

4
dmc-lib/src/scope/mod.rs
View File

@ -1,9 +1,11 @@
use crate::scope::block_scope::BlockScope;
use crate::scope::class_body_scope::ClassBodyScope;
use crate::scope::class_scope::ClassScope;
use crate::scope::function_scope::FunctionScope;
use crate::scope::module_scope::ModuleScope;
pub mod block_scope;
pub mod class_body_scope;
pub mod class_scope;
pub mod function_scope;
pub mod module_scope;
@ -11,6 +13,7 @@ pub mod module_scope;
pub enum Scope {
Module(ModuleScope),
Class(ClassScope),
ClassBody(ClassBodyScope),
Function(FunctionScope),
Block(BlockScope),
}
@ -20,6 +23,7 @@ impl Scope {
match self {
Scope::Module(module_scope) => module_scope.parent_id(),
Scope::Class(class_scope) => Some(class_scope.parent_id()),
Scope::ClassBody(class_body_scope) => Some(class_body_scope.parent_id()),
Scope::Function(function_scope) => Some(function_scope.parent_id()),
Scope::Block(block_scope) => Some(block_scope.parent_id()),
}

13
dmc-lib/src/scope/module_scope.rs
View File

@ -1,14 +1,13 @@
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
pub struct ModuleScope {
debug_name: String,
parent_id: Option<usize>,
class_symbols: HashMap<Rc<str>, Rc<RefCell<ClassSymbol>>>,
function_symbols: HashMap<Rc<str>, Rc<RefCell<FunctionSymbol>>>,
class_symbols: HashMap<Rc<str>, Rc<ClassSymbol>>,
function_symbols: HashMap<Rc<str>, Rc<FunctionSymbol>>,
}
impl ModuleScope {
@ -21,19 +20,19 @@ impl ModuleScope {
}
}
pub fn class_symbols(&self) -> &HashMap<Rc<str>, Rc<RefCell<ClassSymbol>>> {
pub fn class_symbols(&self) -> &HashMap<Rc<str>, Rc<ClassSymbol>> {
&self.class_symbols
}
pub fn class_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<RefCell<ClassSymbol>>> {
pub fn class_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<ClassSymbol>> {
&mut self.class_symbols
}
pub fn function_symbols(&self) -> &HashMap<Rc<str>, Rc<RefCell<FunctionSymbol>>> {
pub fn function_symbols(&self) -> &HashMap<Rc<str>, Rc<FunctionSymbol>> {
&self.function_symbols
}
pub fn function_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<RefCell<FunctionSymbol>>> {
pub fn function_symbols_mut(&mut self) -> &mut HashMap<Rc<str>, Rc<FunctionSymbol>> {
&mut self.function_symbols
}

25
dmc-lib/src/symbol/callable_symbol.rs
View File

@ -1,34 +1,19 @@
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::type_info::TypeInfo;
use std::cell::RefCell;
use std::rc::Rc;
pub enum CallableSymbol {
Function(Rc<RefCell<FunctionSymbol>>),
Class(Rc<RefCell<ClassSymbol>>),
Function(Rc<FunctionSymbol>),
Class(Rc<ClassSymbol>),
}
impl CallableSymbol {
pub fn return_type_info(&self) -> TypeInfo {
pub fn parameters(&self) -> Vec<Rc<ParameterSymbol>> {
match self {
CallableSymbol::Function(function) => function.borrow().return_type_info().clone(),
CallableSymbol::Class(class_symbol) => TypeInfo::ClassInstance(class_symbol.clone()),
}
}
pub fn parameters(&self) -> Vec<Rc<RefCell<ParameterSymbol>>> {
match self {
CallableSymbol::Function(function_symbol) => {
function_symbol.borrow().parameters().to_vec()
}
CallableSymbol::Function(function_symbol) => function_symbol.parameters().to_vec(),
CallableSymbol::Class(class_symbol) => {
if let Some(constructor_symbol) = class_symbol.borrow().constructor_symbol() {
constructor_symbol.borrow().parameters().to_vec()
} else {
vec![]
}
class_symbol.constructor_symbol().parameters().to_vec()
}
}
}

91
dmc-lib/src/symbol/class_symbol.rs
View File

@ -1,11 +1,10 @@
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::symbol::constructor_symbol::ConstructorSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol::generic_parameter_symbol::GenericParameterSymbol;
use std::cell::RefCell;
use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use std::rc::Rc;
pub struct ClassSymbol {
@ -13,74 +12,92 @@ pub struct ClassSymbol {
declared_name_source_range: SourceRange,
fqn_parts: Vec<Rc<str>>,
is_extern: bool,
generic_parameters: Vec<Rc<RefCell<GenericParameterSymbol>>>,
constructor_symbol: Option<Rc<RefCell<ConstructorSymbol>>>,
fields: HashMap<Rc<str>, Rc<RefCell<FieldSymbol>>>,
functions: HashMap<Rc<str>, Rc<RefCell<FunctionSymbol>>>,
scope_id: usize,
generic_parameters: Vec<Rc<GenericParameterSymbol>>,
constructor_symbol: Rc<ConstructorSymbol>,
fields: HashMap<Rc<str>, Rc<FieldSymbol>>,
functions: HashMap<Rc<str>, Rc<FunctionSymbol>>,
}
impl ClassSymbol {
pub fn new(
declared_name: &Rc<str>,
declared_name_source_range: SourceRange,
declared_name_source_range: &SourceRange,
fqn_parts: Vec<Rc<str>>,
is_extern: bool,
scope_id: usize,
generic_parameters: Vec<Rc<GenericParameterSymbol>>,
constructor_symbol: Rc<ConstructorSymbol>,
fields: Vec<Rc<FieldSymbol>>,
functions: Vec<Rc<FunctionSymbol>>,
) -> Self {
Self {
declared_name: declared_name.clone(),
declared_name_source_range,
declared_name_source_range: declared_name_source_range.clone(),
fqn_parts,
is_extern,
generic_parameters: vec![],
constructor_symbol: None,
fields: HashMap::new(),
functions: HashMap::new(),
scope_id,
generic_parameters,
constructor_symbol,
fields: fields
.into_iter()
.map(|fs| (fs.declared_name_owned(), fs))
.collect(),
functions: functions
.into_iter()
.map(|fs| (fs.declared_name_owned(), fs))
.collect(),
}
}
pub fn declared_name(&self) -> &str {
&self.declared_name
}
pub fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
pub fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
}
pub fn fqn_parts(&self) -> &[Rc<str>] {
&self.fqn_parts
}
pub fn set_generic_parameters(
&mut self,
generic_parameters: Vec<Rc<RefCell<GenericParameterSymbol>>>,
) {
self.generic_parameters = generic_parameters;
pub fn scope_id(&self) -> usize {
self.scope_id
}
pub fn generic_parameters(&self) -> &[Rc<RefCell<GenericParameterSymbol>>] {
pub fn generic_parameters(&self) -> &[Rc<GenericParameterSymbol>] {
&self.generic_parameters
}
pub fn set_constructor_symbol(&mut self, constructor_symbol: Rc<RefCell<ConstructorSymbol>>) {
self.constructor_symbol = Some(constructor_symbol);
pub fn constructor_symbol(&self) -> &ConstructorSymbol {
&self.constructor_symbol
}
pub fn set_fields(&mut self, fields: HashMap<Rc<str>, Rc<RefCell<FieldSymbol>>>) {
self.fields = fields;
}
pub fn fields(&self) -> &HashMap<Rc<str>, Rc<RefCell<FieldSymbol>>> {
pub fn fields(&self) -> &HashMap<Rc<str>, Rc<FieldSymbol>> {
&self.fields
}
/// A value of `None` indicates that there is no declared constructor for this class.
pub fn constructor_symbol(&self) -> Option<&Rc<RefCell<ConstructorSymbol>>> {
self.constructor_symbol.as_ref()
pub fn functions(&self) -> &HashMap<Rc<str>, Rc<FunctionSymbol>> {
&self.functions
}
}
impl Symbol for ClassSymbol {
fn declared_name(&self) -> &str {
&self.declared_name
impl Eq for ClassSymbol {}
impl PartialEq for ClassSymbol {
fn eq(&self, other: &Self) -> bool {
self.declared_name == other.declared_name && self.scope_id == other.scope_id
}
}
fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
impl Hash for ClassSymbol {
fn hash<H: Hasher>(&self, state: &mut H) {
self.declared_name.hash(state);
self.scope_id.hash(state);
}
}

53
dmc-lib/src/symbol/constructor_symbol.rs
View File

@ -1,7 +1,6 @@
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use std::cell::RefCell;
use std::hash::{Hash, Hasher};
use std::rc::Rc;
pub struct ConstructorSymbol {
@ -9,35 +8,51 @@ pub struct ConstructorSymbol {
fqn_parts: Vec<Rc<str>>,
is_extern: bool,
is_default: bool,
parameters: Option<Vec<Rc<RefCell<ParameterSymbol>>>>,
scope_id: usize,
parameters: Vec<Rc<ParameterSymbol>>,
}
impl ConstructorSymbol {
pub fn new(
keyword_source_range: SourceRange,
keyword_source_range: &SourceRange,
fqn_parts: Vec<Rc<str>>,
is_extern: bool,
is_default: bool,
scope_id: usize,
parameters: Vec<Rc<ParameterSymbol>>,
) -> Self {
Self {
keyword_source_range,
keyword_source_range: keyword_source_range.clone(),
fqn_parts,
is_extern,
is_default,
parameters: None,
scope_id,
parameters,
}
}
pub fn declared_name(&self) -> &str {
"ctor"
}
pub fn declared_name_owned(&self) -> Rc<str> {
Rc::from(self.declared_name())
}
pub fn declared_name_source_range(&self) -> &SourceRange {
&self.keyword_source_range
}
pub fn fqn_parts(&self) -> &[Rc<str>] {
&self.fqn_parts
}
pub fn set_parameters(&mut self, parameters: Vec<Rc<RefCell<ParameterSymbol>>>) {
self.parameters = Some(parameters);
pub fn scope_id(&self) -> usize {
self.scope_id
}
pub fn parameters(&self) -> &[Rc<RefCell<ParameterSymbol>>] {
self.parameters.as_ref().unwrap()
pub fn parameters(&self) -> &[Rc<ParameterSymbol>] {
&self.parameters
}
pub fn is_extern(&self) -> bool {
@ -45,16 +60,16 @@ impl ConstructorSymbol {
}
}
impl Symbol for ConstructorSymbol {
fn declared_name(&self) -> &str {
"ctor"
impl Eq for ConstructorSymbol {}
impl PartialEq for ConstructorSymbol {
fn eq(&self, other: &Self) -> bool {
self.scope_id == other.scope_id
}
}
fn declared_name_owned(&self) -> Rc<str> {
Rc::from(self.declared_name())
}
fn declared_name_source_range(&self) -> &SourceRange {
&self.keyword_source_range
impl Hash for ConstructorSymbol {
fn hash<H: Hasher>(&self, state: &mut H) {
self.scope_id.hash(state);
}
}

97
dmc-lib/src/symbol/expressible_symbol.rs
View File

@ -1,111 +1,36 @@
use crate::ast::ir_builder::IrBuilder;
use crate::ast::ir_util::get_or_init_field_pointer_variable;
use crate::ir::ir_assign::IrAssign;
use crate::ir::ir_expression::IrExpression;
use crate::ir::ir_operation::IrOperation;
use crate::ir::ir_read_field::IrReadField;
use crate::ir::ir_statement::IrStatement;
use crate::ir::ir_variable::IrVariable;
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol::variable_symbol::VariableSymbol;
use crate::type_info::TypeInfo;
use std::cell::RefCell;
use std::rc::Rc;
pub enum ExpressibleSymbol {
Class(Rc<RefCell<ClassSymbol>>),
Field(Rc<RefCell<FieldSymbol>>),
Function(Rc<RefCell<FunctionSymbol>>),
Parameter(Rc<RefCell<ParameterSymbol>>),
Variable(Rc<RefCell<VariableSymbol>>),
Class(Rc<ClassSymbol>),
Field(Rc<FieldSymbol>),
Function(Rc<FunctionSymbol>),
Parameter(Rc<ParameterSymbol>),
Variable(Rc<VariableSymbol>),
}
impl ExpressibleSymbol {
pub fn type_info(&self) -> TypeInfo {
match self {
ExpressibleSymbol::Class(class_symbol) => TypeInfo::ClassInstance(class_symbol.clone()),
ExpressibleSymbol::Field(field_symbol) => field_symbol.borrow().type_info().clone(),
ExpressibleSymbol::Function(function_symbol) => {
TypeInfo::Function(function_symbol.clone()) // n.b. not the return type!
}
ExpressibleSymbol::Parameter(parameter_symbol) => {
parameter_symbol.borrow().type_info().clone()
}
ExpressibleSymbol::Variable(variable_symbol) => {
variable_symbol.borrow().type_info().clone()
}
}
}
pub fn is_mut(&self) -> bool {
match self {
ExpressibleSymbol::Field(field_symbol) => field_symbol.borrow().is_mut(),
ExpressibleSymbol::Variable(variable_symbol) => variable_symbol.borrow().is_mut(),
_ => false,
}
}
pub fn source_range(&self) -> SourceRange {
match self {
ExpressibleSymbol::Class(class_symbol) => {
class_symbol.borrow().declared_name_source_range().clone()
class_symbol.declared_name_source_range().clone()
}
ExpressibleSymbol::Field(field_symbol) => {
field_symbol.borrow().declared_name_source_range().clone()
field_symbol.declared_name_source_range().clone()
}
ExpressibleSymbol::Function(function_symbol) => function_symbol
.borrow()
.declared_name_source_range()
.clone(),
ExpressibleSymbol::Parameter(parameter_symbol) => parameter_symbol
.borrow()
.declared_name_source_range()
.clone(),
ExpressibleSymbol::Variable(variable_symbol) => variable_symbol
.borrow()
.declared_name_source_range()
.clone(),
}
}
pub fn ir_expression(&self, builder: &mut IrBuilder) -> IrExpression {
match self {
ExpressibleSymbol::Class(class_symbol) => {
todo!()
}
ExpressibleSymbol::Field(field_symbol) => {
// now we need to read the field into a variable and return an expression pointing
// to that variable
let read_destination = IrVariable::new_vr(
builder.new_t_var().into(),
builder.current_block().id(),
field_symbol.borrow().type_info(),
);
let read_destination_as_rc = Rc::new(RefCell::new(read_destination));
let ir_read_field = IrReadField::new(
get_or_init_field_pointer_variable(builder, field_symbol).clone(),
);
builder
.current_block_mut()
.add_statement(IrStatement::Assign(IrAssign::new(
read_destination_as_rc.clone(),
IrOperation::ReadField(ir_read_field),
)));
IrExpression::Variable(read_destination_as_rc)
}
ExpressibleSymbol::Function(_) => {
panic!("Cannot get ir_variable for FunctionSymbol");
ExpressibleSymbol::Function(function_symbol) => {
function_symbol.declared_name_source_range().clone()
}
ExpressibleSymbol::Parameter(parameter_symbol) => {
IrExpression::Parameter(parameter_symbol.borrow().ir_parameter().clone())
parameter_symbol.declared_name_source_range().clone()
}
ExpressibleSymbol::Variable(variable_symbol) => {
IrExpression::Variable(variable_symbol.borrow().vr_variable().clone())
variable_symbol.declared_name_source_range().clone()
}
}
}

40
dmc-lib/src/symbol/field_symbol.rs
View File

@ -1,12 +1,13 @@
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::type_info::TypeInfo;
use std::hash::{Hash, Hasher};
use std::rc::Rc;
pub struct FieldSymbol {
declared_name: Rc<str>,
declared_name_source_range: SourceRange,
is_mut: bool,
scope_id: usize,
type_info: Option<TypeInfo>,
field_index: Option<usize>,
}
@ -16,16 +17,34 @@ impl FieldSymbol {
declared_name: &Rc<str>,
declared_name_source_range: SourceRange,
is_mut: bool,
scope_id: usize,
) -> Self {
Self {
declared_name: declared_name.clone(),
declared_name_source_range,
is_mut,
scope_id,
type_info: None,
field_index: None,
}
}
pub fn declared_name(&self) -> &str {
&self.declared_name
}
pub fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
pub fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
}
pub fn scope_id(&self) -> usize {
self.scope_id
}
pub fn is_mut(&self) -> bool {
self.is_mut
}
@ -47,16 +66,17 @@ impl FieldSymbol {
}
}
impl Symbol for FieldSymbol {
fn declared_name(&self) -> &str {
&self.declared_name
impl Eq for FieldSymbol {}
impl PartialEq for FieldSymbol {
fn eq(&self, other: &Self) -> bool {
self.declared_name == other.declared_name && self.scope_id == other.scope_id
}
}
fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
impl Hash for FieldSymbol {
fn hash<H: Hasher>(&self, state: &mut H) {
self.declared_name.hash(state);
self.scope_id.hash(state);
}
}

69
dmc-lib/src/symbol/function_symbol.rs
View File

@ -1,8 +1,6 @@
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::type_info::TypeInfo;
use std::cell::RefCell;
use std::hash::Hash;
use std::rc::Rc;
pub struct FunctionSymbol {
@ -10,45 +8,57 @@ pub struct FunctionSymbol {
declared_name_source_range: SourceRange,
fqn_parts: Vec<Rc<str>>,
is_extern: bool,
parameters: Option<Vec<Rc<RefCell<ParameterSymbol>>>>,
return_type: Option<TypeInfo>,
is_method: bool,
scope_id: usize,
parameters: Vec<Rc<ParameterSymbol>>,
}
impl FunctionSymbol {
pub fn new(
declared_name: &str,
declared_name: &Rc<str>,
declared_name_source_range: SourceRange,
fqn_parts: Vec<Rc<str>>,
is_extern: bool,
is_method: bool,
scope_id: usize,
parameters: Vec<Rc<ParameterSymbol>>,
) -> Self {
Self {
declared_name: declared_name.into(),
declared_name: declared_name.clone(),
declared_name_source_range,
fqn_parts,
is_extern,
parameters: None,
return_type: None,
is_method,
scope_id,
parameters,
}
}
pub fn declared_name(&self) -> &str {
&self.declared_name
}
pub fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
pub fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
}
pub fn fqn_parts(&self) -> &[Rc<str>] {
&self.fqn_parts
}
pub fn set_parameters(&mut self, parameters: Vec<Rc<RefCell<ParameterSymbol>>>) {
self.parameters = Some(parameters);
pub fn is_method(&self) -> bool {
self.is_method
}
pub fn parameters(&self) -> &[Rc<RefCell<ParameterSymbol>>] {
self.parameters.as_ref().unwrap()
pub fn scope_id(&self) -> usize {
self.scope_id
}
pub fn set_return_type_info(&mut self, return_type: TypeInfo) {
self.return_type = Some(return_type);
}
pub fn return_type_info(&self) -> &TypeInfo {
self.return_type.as_ref().unwrap()
pub fn parameters(&self) -> &[Rc<ParameterSymbol>] {
&self.parameters
}
pub fn is_extern(&self) -> bool {
@ -56,16 +66,17 @@ impl FunctionSymbol {
}
}
impl Symbol for FunctionSymbol {
fn declared_name(&self) -> &str {
&self.declared_name
impl Eq for FunctionSymbol {}
impl PartialEq for FunctionSymbol {
fn eq(&self, other: &Self) -> bool {
self.declared_name == other.declared_name && self.scope_id == other.scope_id
}
}
fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
impl Hash for FunctionSymbol {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.declared_name.hash(state);
self.scope_id.hash(state);
}
}

45
dmc-lib/src/symbol/generic_parameter_symbol.rs
View File

@ -1,23 +1,45 @@
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::type_info::TypeInfo;
use std::hash::{Hash, Hasher};
use std::rc::Rc;
pub struct GenericParameterSymbol {
declared_name: Rc<str>,
declared_name_source_range: SourceRange,
scope_id: usize,
extends: Option<Vec<TypeInfo>>,
}
impl GenericParameterSymbol {
pub fn new(declared_name: &Rc<str>, declared_name_source_range: &SourceRange) -> Self {
pub fn new(
declared_name: &Rc<str>,
declared_name_source_range: &SourceRange,
scope_id: usize,
) -> Self {
Self {
declared_name: declared_name.clone(),
declared_name_source_range: declared_name_source_range.clone(),
scope_id,
extends: None,
}
}
pub fn declared_name(&self) -> &str {
&self.declared_name
}
pub fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
pub fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
}
pub fn scope_id(&self) -> usize {
self.scope_id
}
pub fn set_extends(&mut self, extends: Vec<TypeInfo>) {
self.extends = Some(extends);
}
@ -27,16 +49,17 @@ impl GenericParameterSymbol {
}
}
impl Symbol for GenericParameterSymbol {
fn declared_name(&self) -> &str {
&self.declared_name
impl Eq for GenericParameterSymbol {}
impl PartialEq for GenericParameterSymbol {
fn eq(&self, other: &Self) -> bool {
self.declared_name == other.declared_name && self.scope_id == other.scope_id
}
}
fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
impl Hash for GenericParameterSymbol {
fn hash<H: Hasher>(&self, state: &mut H) {
self.declared_name.hash(state);
self.scope_id.hash(state);
}
}

66
dmc-lib/src/symbol/mod.rs
View File

@ -1,4 +1,11 @@
use crate::source_range::SourceRange;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::constructor_symbol::ConstructorSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol::generic_parameter_symbol::GenericParameterSymbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol::variable_symbol::VariableSymbol;
use std::rc::Rc;
pub mod callable_symbol;
@ -12,8 +19,59 @@ pub mod parameter_symbol;
pub mod type_symbol;
pub mod variable_symbol;
pub trait Symbol {
fn declared_name(&self) -> &str;
fn declared_name_owned(&self) -> Rc<str>;
fn declared_name_source_range(&self) -> &SourceRange;
#[derive(Eq, PartialEq, Hash)]
pub enum Symbol {
Class(Rc<ClassSymbol>),
GenericParameter(Rc<GenericParameterSymbol>),
Field(Rc<FieldSymbol>),
Constructor(Rc<ConstructorSymbol>),
Function(Rc<FunctionSymbol>),
Parameter(Rc<ParameterSymbol>),
Variable(Rc<VariableSymbol>),
}
impl Symbol {
pub fn scope_id(&self) -> usize {
match self {
Symbol::Class(class_symbol) => class_symbol.scope_id(),
Symbol::GenericParameter(generic_parameter_symbol) => {
generic_parameter_symbol.scope_id()
}
Symbol::Field(field_symbol) => field_symbol.scope_id(),
Symbol::Constructor(constructor_symbol) => constructor_symbol.scope_id(),
Symbol::Function(function_symbol) => function_symbol.scope_id(),
Symbol::Parameter(parameter_symbol) => parameter_symbol.scope_id(),
Symbol::Variable(variable_symbol) => variable_symbol.scope_id(),
}
}
pub fn declared_name(&self) -> &str {
match self {
Symbol::Class(class_symbol) => class_symbol.declared_name(),
Symbol::GenericParameter(generic_parameter_symbol) => {
generic_parameter_symbol.declared_name()
}
Symbol::Field(field_symbol) => field_symbol.declared_name(),
Symbol::Constructor(constructor_symbol) => constructor_symbol.declared_name(),
Symbol::Function(function_symbol) => function_symbol.declared_name(),
Symbol::Parameter(parameter_symbol) => parameter_symbol.declared_name(),
Symbol::Variable(variable_symbol) => variable_symbol.declared_name(),
}
}
pub fn declared_name_source_range(&self) -> &SourceRange {
match self {
Symbol::Class(class_symbol) => class_symbol.declared_name_source_range(),
Symbol::GenericParameter(generic_parameter_symbol) => {
generic_parameter_symbol.declared_name_source_range()
}
Symbol::Field(field_symbol) => field_symbol.declared_name_source_range(),
Symbol::Constructor(constructor_symbol) => {
constructor_symbol.declared_name_source_range()
}
Symbol::Function(function_symbol) => function_symbol.declared_name_source_range(),
Symbol::Parameter(parameter_symbol) => parameter_symbol.declared_name_source_range(),
Symbol::Variable(variable_symbol) => variable_symbol.declared_name_source_range(),
}
}
}

59
dmc-lib/src/symbol/parameter_symbol.rs
View File

@ -1,53 +1,54 @@
use crate::ir::ir_parameter::IrParameter;
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::type_info::TypeInfo;
use std::hash::{Hash, Hasher};
use std::rc::Rc;
pub struct ParameterSymbol {
declared_name: Rc<str>,
declared_name_source_range: SourceRange,
type_info: Option<TypeInfo>,
ir_parameter: Option<Rc<IrParameter>>,
scope_id: usize,
}
impl ParameterSymbol {
pub fn new(declared_name: &Rc<str>, declared_name_source_range: SourceRange) -> Self {
pub fn new(
declared_name: &Rc<str>,
declared_name_source_range: SourceRange,
scope_id: usize,
) -> Self {
Self {
declared_name: declared_name.clone(),
declared_name_source_range,
type_info: None,
ir_parameter: None,
scope_id,
}
}
pub fn set_type_info(&mut self, type_info: TypeInfo) {
self.type_info = Some(type_info);
}
pub fn type_info(&self) -> &TypeInfo {
self.type_info.as_ref().unwrap()
}
pub fn set_ir_parameter(&mut self, ir_parameter: Rc<IrParameter>) {
self.ir_parameter = Some(ir_parameter);
}
pub fn ir_parameter(&self) -> &Rc<IrParameter> {
self.ir_parameter.as_ref().unwrap()
}
}
impl Symbol for ParameterSymbol {
fn declared_name(&self) -> &str {
pub fn declared_name(&self) -> &str {
&self.declared_name
}
fn declared_name_owned(&self) -> Rc<str> {
pub fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
fn declared_name_source_range(&self) -> &SourceRange {
pub fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
}
pub fn scope_id(&self) -> usize {
self.scope_id
}
}
impl Eq for ParameterSymbol {}
impl PartialEq for ParameterSymbol {
fn eq(&self, other: &Self) -> bool {
self.declared_name == other.declared_name && self.scope_id == other.scope_id
}
}
impl Hash for ParameterSymbol {
fn hash<H: Hasher>(&self, state: &mut H) {
self.declared_name.hash(state);
self.scope_id.hash(state);
}
}

5
dmc-lib/src/symbol/type_symbol.rs
View File

@ -1,9 +1,8 @@
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::generic_parameter_symbol::GenericParameterSymbol;
use std::cell::RefCell;
use std::rc::Rc;
pub enum TypeSymbol {
Class(Rc<RefCell<ClassSymbol>>),
GenericParameter(Rc<RefCell<GenericParameterSymbol>>),
Class(Rc<ClassSymbol>),
GenericParameter(Rc<GenericParameterSymbol>),
}

71
dmc-lib/src/symbol/variable_symbol.rs
View File

@ -1,64 +1,61 @@
use crate::ir::ir_variable::IrVariable;
use crate::source_range::SourceRange;
use crate::symbol::Symbol;
use crate::type_info::TypeInfo;
use std::cell::RefCell;
use std::hash::{Hash, Hasher};
use std::rc::Rc;
pub struct VariableSymbol {
declared_name: Rc<str>,
declared_name_source_range: SourceRange,
is_mut: bool,
type_info: Option<TypeInfo>,
vr_variable: Option<Rc<RefCell<IrVariable>>>,
scope_id: usize,
}
impl VariableSymbol {
pub fn new(name: &Rc<str>, declared_name_source_range: SourceRange, is_mut: bool) -> Self {
pub fn new(
name: &Rc<str>,
declared_name_source_range: &SourceRange,
is_mut: bool,
scope_id: usize,
) -> Self {
Self {
declared_name: name.clone(),
declared_name_source_range,
declared_name_source_range: declared_name_source_range.clone(),
is_mut,
type_info: None,
vr_variable: None,
scope_id,
}
}
pub fn declared_name(&self) -> &str {
&self.declared_name
}
pub fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
pub fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
}
pub fn is_mut(&self) -> bool {
self.is_mut
}
pub fn set_type_info(&mut self, type_info: TypeInfo) {
self.type_info = Some(type_info);
}
pub fn type_info(&self) -> &TypeInfo {
self.type_info
.as_ref()
.expect("TypeInfo not initialized. Did you type check?")
}
pub fn set_vr_variable(&mut self, ir_variable: Rc<RefCell<IrVariable>>) {
self.vr_variable = Some(ir_variable);
}
pub fn vr_variable(&self) -> &Rc<RefCell<IrVariable>> {
self.vr_variable
.as_ref()
.expect("ir_variable not yet initialized")
pub fn scope_id(&self) -> usize {
self.scope_id
}
}
impl Symbol for VariableSymbol {
fn declared_name(&self) -> &str {
&self.declared_name
impl Eq for VariableSymbol {}
impl PartialEq for VariableSymbol {
fn eq(&self, other: &Self) -> bool {
self.declared_name == other.declared_name && self.scope_id == other.scope_id
}
}
fn declared_name_owned(&self) -> Rc<str> {
self.declared_name.clone()
}
fn declared_name_source_range(&self) -> &SourceRange {
&self.declared_name_source_range
impl Hash for VariableSymbol {
fn hash<H: Hasher>(&self, state: &mut H) {
self.declared_name.hash(state);
self.scope_id.hash(state);
}
}

264
dmc-lib/src/symbol_table/helpers.rs
View File

@ -1,134 +1,210 @@
use crate::scope::Scope;
use crate::scope::block_scope::BlockScope;
use crate::scope::class_body_scope::ClassBodyScope;
use crate::scope::class_scope::ClassScope;
use crate::scope::function_scope::FunctionScope;
use crate::scope::module_scope::ModuleScope;
use crate::symbol::Symbol;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::expressible_symbol::ExpressibleSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol::generic_parameter_symbol::GenericParameterSymbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol::type_symbol::TypeSymbol;
use std::cell::RefCell;
use crate::symbol::variable_symbol::VariableSymbol;
use std::collections::HashMap;
use std::rc::Rc;
pub fn find_in_module_by_name(
module_scope: &ModuleScope,
fn find_class_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<ClassSymbol>>,
name: &str,
) -> Option<Rc<RefCell<dyn Symbol>>> {
module_scope
.function_symbols()
) -> Option<Symbol> {
symbols
.get(name)
.map(|symbol| symbol.clone() as Rc<RefCell<dyn Symbol>>)
.or_else(|| {
module_scope
.class_symbols()
.get(name)
.map(|symbol| symbol.clone() as Rc<RefCell<dyn Symbol>>)
})
.map(|symbol| Symbol::Class(symbol.clone()))
}
pub fn find_in_class_by_name(
class_scope: &ClassScope,
fn find_generic_parameter_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<GenericParameterSymbol>>,
name: &str,
) -> Option<Rc<RefCell<dyn Symbol>>> {
class_scope
.class_symbols()
) -> Option<Symbol> {
symbols
.get(name)
.map(|symbol| symbol.clone() as Rc<RefCell<dyn Symbol>>)
.or_else(|| {
class_scope
.function_symbols()
.get(name)
.map(|symbol| symbol.clone() as Rc<RefCell<dyn Symbol>>)
})
.or_else(|| {
class_scope
.field_symbols()
.get(name)
.map(|symbol| symbol.clone() as Rc<RefCell<dyn Symbol>>)
})
.map(|symbol| Symbol::GenericParameter(symbol.clone()))
}
pub fn find_in_function_by_name(
function_scope: &FunctionScope,
fn find_field_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<FieldSymbol>>,
name: &str,
) -> Option<Rc<RefCell<dyn Symbol>>> {
function_scope
.parameter_symbols()
) -> Option<Symbol> {
symbols
.get(name)
.map(|symbol| symbol.clone() as Rc<RefCell<dyn Symbol>>)
.map(|symbol| Symbol::Field(symbol.clone()))
}
pub fn find_in_block_by_name(
block_scope: &BlockScope,
fn find_function_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<FunctionSymbol>>,
name: &str,
) -> Option<Rc<RefCell<dyn Symbol>>> {
block_scope
.variable_symbols()
) -> Option<Symbol> {
symbols
.get(name)
.map(|symbol| symbol.clone() as Rc<RefCell<dyn Symbol>>)
.map(|symbol| Symbol::Function(symbol.clone()))
}
fn find_parameter_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<ParameterSymbol>>,
name: &str,
) -> Option<Symbol> {
symbols
.get(name)
.map(|symbol| Symbol::Parameter(symbol.clone()))
}
fn find_variable_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<VariableSymbol>>,
name: &str,
) -> Option<Symbol> {
symbols
.get(name)
.map(|symbol| Symbol::Variable(symbol.clone()))
}
/* Expressible symbol refs */
fn find_class_expressible_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<ClassSymbol>>,
name: &str,
) -> Option<ExpressibleSymbol> {
symbols
.get(name)
.map(|symbol| ExpressibleSymbol::Class(symbol.clone()))
}
fn find_field_expressible_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<FieldSymbol>>,
name: &str,
) -> Option<ExpressibleSymbol> {
symbols
.get(name)
.map(|symbol| ExpressibleSymbol::Field(symbol.clone()))
}
fn find_function_expressible_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<FunctionSymbol>>,
name: &str,
) -> Option<ExpressibleSymbol> {
symbols
.get(name)
.map(|symbol| ExpressibleSymbol::Function(symbol.clone()))
}
fn find_parameter_expressible_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<ParameterSymbol>>,
name: &str,
) -> Option<ExpressibleSymbol> {
symbols
.get(name)
.map(|symbol| ExpressibleSymbol::Parameter(symbol.clone()))
}
fn find_variable_expressible_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<VariableSymbol>>,
name: &str,
) -> Option<ExpressibleSymbol> {
symbols
.get(name)
.map(|symbol| ExpressibleSymbol::Variable(symbol.clone()))
}
/* Find type symbols */
fn find_class_type_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<ClassSymbol>>,
name: &str,
) -> Option<TypeSymbol> {
symbols
.get(name)
.map(|symbol| TypeSymbol::Class(symbol.clone()))
}
fn find_generic_parameter_type_symbol_ref(
symbols: &HashMap<Rc<str>, Rc<GenericParameterSymbol>>,
name: &str,
) -> Option<TypeSymbol> {
symbols
.get(name)
.map(|symbol| TypeSymbol::GenericParameter(symbol.clone()))
}
/* Public helper functions */
/* Various find in functions */
pub fn find_in_module_by_name(module_scope: &ModuleScope, name: &str) -> Option<Symbol> {
find_function_symbol_ref(&module_scope.function_symbols(), name)
.or_else(|| find_class_symbol_ref(&module_scope.class_symbols(), name))
}
pub fn find_in_class_by_name(class_scope: &ClassScope, name: &str) -> Option<Symbol> {
find_generic_parameter_symbol_ref(&class_scope.generic_parameter_symbols(), name)
}
pub fn find_in_class_body_by_name(class_body_scope: &ClassBodyScope, name: &str) -> Option<Symbol> {
find_class_symbol_ref(&class_body_scope.class_symbols(), name)
.or_else(|| find_function_symbol_ref(&class_body_scope.function_symbols(), name))
.or_else(|| find_field_symbol_ref(&class_body_scope.field_symbols(), name))
}
pub fn find_in_function_by_name(function_scope: &FunctionScope, name: &str) -> Option<Symbol> {
find_parameter_symbol_ref(&function_scope.parameter_symbols(), name)
}
pub fn find_in_block_by_name(block_scope: &BlockScope, name: &str) -> Option<Symbol> {
find_variable_symbol_ref(&block_scope.variable_symbols(), name)
}
/* Find expressible */
fn find_expressible_in_module_by_name(
module_scope: &ModuleScope,
name: &str,
) -> Option<ExpressibleSymbol> {
module_scope
.class_symbols()
.get(name)
.map(|class_symbol| ExpressibleSymbol::Class(class_symbol.clone()))
.or_else(|| {
module_scope
.function_symbols()
.get(name)
.map(|function_symbol| ExpressibleSymbol::Function(function_symbol.clone()))
})
find_class_expressible_symbol_ref(&module_scope.class_symbols(), name)
.or_else(|| find_function_expressible_symbol_ref(&module_scope.function_symbols(), name))
}
fn find_expressible_in_class_by_name(
class_scope: &ClassScope,
fn find_expressible_in_class_body_by_name(
class_body_scope: &ClassBodyScope,
name: &str,
) -> Option<ExpressibleSymbol> {
class_scope
.class_symbols()
.get(name)
.map(|symbol| ExpressibleSymbol::Class(symbol.clone()))
find_class_expressible_symbol_ref(&class_body_scope.class_symbols(), name)
.or_else(|| {
class_scope
.function_symbols()
.get(name)
.map(|function_symbol| ExpressibleSymbol::Function(function_symbol.clone()))
})
.or_else(|| {
class_scope
.field_symbols()
.get(name)
.map(|field_symbol| ExpressibleSymbol::Field(field_symbol.clone()))
find_function_expressible_symbol_ref(&class_body_scope.function_symbols(), name)
})
.or_else(|| find_field_expressible_symbol_ref(&class_body_scope.field_symbols(), name))
}
fn find_expressible_in_function_by_name(
function_scope: &FunctionScope,
name: &str,
) -> Option<ExpressibleSymbol> {
function_scope
.parameter_symbols()
.get(name)
.map(|parameter_symbol| ExpressibleSymbol::Parameter(parameter_symbol.clone()))
find_parameter_expressible_symbol_ref(function_scope.parameter_symbols(), name)
}
fn find_expressible_in_block_by_name(
block_scope: &BlockScope,
name: &str,
) -> Option<ExpressibleSymbol> {
block_scope
.variable_symbols()
.get(name)
.map(|variable_symbol| ExpressibleSymbol::Variable(variable_symbol.clone()))
find_variable_expressible_symbol_ref(block_scope.variable_symbols(), name)
}
pub fn find_expressible_symbol(scope: &Scope, name: &str) -> Option<ExpressibleSymbol> {
match scope {
Scope::Module(module_scope) => find_expressible_in_module_by_name(module_scope, name),
Scope::Class(class_scope) => find_expressible_in_class_by_name(class_scope, name),
Scope::Class(_) => None,
Scope::ClassBody(class_body_scope) => {
find_expressible_in_class_body_by_name(class_body_scope, name)
}
Scope::Function(function_scope) => {
find_expressible_in_function_by_name(function_scope, name)
}
@ -136,32 +212,30 @@ pub fn find_expressible_symbol(scope: &Scope, name: &str) -> Option<ExpressibleS
}
}
/* Find type */
fn find_type_symbol_in_module(module_scope: &ModuleScope, name: &str) -> Option<TypeSymbol> {
module_scope
.class_symbols()
.get(name)
.map(|symbol| TypeSymbol::Class(symbol.clone()))
find_class_type_symbol_ref(&module_scope.class_symbols(), name)
}
pub fn find_type_symbol_in_class(class_scope: &ClassScope, name: &str) -> Option<TypeSymbol> {
class_scope
.class_symbols()
.get(name)
.map(|symbol| TypeSymbol::Class(symbol.clone()))
.or_else(|| {
class_scope
.generic_parameter_symbols()
.get(name)
.map(|generic_parameter_symbol| {
TypeSymbol::GenericParameter(generic_parameter_symbol.clone())
})
})
fn find_type_symbol_in_class_body(
class_body_scope: &ClassBodyScope,
name: &str,
) -> Option<TypeSymbol> {
find_class_type_symbol_ref(&class_body_scope.class_symbols(), name)
}
fn find_type_symbol_in_class(class_scope: &ClassScope, name: &str) -> Option<TypeSymbol> {
find_generic_parameter_type_symbol_ref(&class_scope.generic_parameter_symbols(), name)
}
pub fn find_type_symbol(scope: &Scope, name: &str) -> Option<TypeSymbol> {
match scope {
Scope::Module(module_scope) => find_type_symbol_in_module(module_scope, name),
Scope::Class(class_scope) => find_type_symbol_in_class(class_scope, name),
Scope::ClassBody(class_body_scope) => {
find_type_symbol_in_class_body(class_body_scope, name)
}
_ => None,
}
}

420
dmc-lib/src/symbol_table/mod.rs
View File

@ -2,6 +2,7 @@ mod helpers;
use crate::scope::Scope;
use crate::scope::block_scope::BlockScope;
use crate::scope::class_body_scope::ClassBodyScope;
use crate::scope::class_scope::ClassScope;
use crate::scope::function_scope::FunctionScope;
use crate::scope::module_scope::ModuleScope;
@ -16,10 +17,9 @@ use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol::type_symbol::TypeSymbol;
use crate::symbol::variable_symbol::VariableSymbol;
use crate::symbol_table::helpers::{
find_expressible_symbol, find_in_block_by_name, find_in_class_by_name,
find_in_function_by_name, find_in_module_by_name, find_type_symbol, find_type_symbol_in_class,
find_expressible_symbol, find_in_block_by_name, find_in_class_body_by_name,
find_in_class_by_name, find_in_function_by_name, find_in_module_by_name, find_type_symbol,
};
use std::cell::RefCell;
use std::rc::Rc;
pub struct SymbolTable {
@ -39,282 +39,210 @@ impl SymbolTable {
self.scopes.len()
}
fn push_scope(&mut self, scope: Scope) {
fn push_scope(&mut self, scope: Scope) -> usize {
let scope_id = self.new_scope_id();
self.scopes.push(scope);
self.current_scope_id = Some(scope_id);
scope_id
}
pub fn push_module_scope(&mut self, debug_name: &str) {
pub fn push_module_scope(&mut self, debug_name: &str) -> usize {
self.push_scope(Scope::Module(ModuleScope::new(
debug_name,
self.current_scope_id,
)));
)))
}
pub fn push_class_scope(&mut self, debug_name: &str) {
pub fn push_class_scope(&mut self, debug_name: &str) -> usize {
self.push_scope(Scope::Class(ClassScope::new(
debug_name,
self.current_scope_id.unwrap(),
)));
)))
}
pub fn push_function_scope(&mut self, debug_name: &str) {
pub fn push_class_body_scope(&mut self, debug_name: &str) -> usize {
self.push_scope(Scope::ClassBody(ClassBodyScope::new(
debug_name,
self.current_scope_id.unwrap(),
)))
}
pub fn push_function_scope(&mut self, debug_name: &str) -> usize {
self.push_scope(Scope::Function(FunctionScope::new(
debug_name,
self.current_scope_id.unwrap(),
)));
)))
}
pub fn push_block_scope(&mut self, debug_name: &str) {
pub fn push_block_scope(&mut self, debug_name: &str) -> usize {
self.push_scope(Scope::Block(BlockScope::new(
debug_name,
self.current_scope_id.unwrap(),
)));
)))
}
pub fn pop_scope(&mut self) {
self.current_scope_id = self.current_scope().parent_id();
self.current_scope_id = self.scopes[self.current_scope_id.unwrap()].parent_id();
}
pub fn current_scope_id(&self) -> usize {
self.current_scope_id.unwrap()
}
fn current_scope(&self) -> &Scope {
&self.scopes[self.current_scope_id.unwrap()]
fn scope(&self, scope_id: usize) -> &Scope {
&self.scopes[scope_id]
}
fn current_scope_mut(&mut self) -> &mut Scope {
&mut self.scopes[self.current_scope_id.unwrap()]
fn scope_mut(&mut self, scope_id: usize) -> &mut Scope {
&mut self.scopes[scope_id]
}
pub fn insert_class_symbol(
&mut self,
class_symbol: ClassSymbol,
) -> Result<Rc<RefCell<ClassSymbol>>, SymbolInsertError> {
let maybe_already_inserted = match self.current_scope() {
pub fn get_symbol(&self, scope_id: usize, name: &str) -> Option<Symbol> {
match self.scope(scope_id) {
Scope::Module(module_scope) => find_in_module_by_name(module_scope, name),
Scope::Class(class_scope) => find_in_class_by_name(class_scope, name),
Scope::ClassBody(class_body_scope) => {
find_in_class_body_by_name(class_body_scope, name)
}
Scope::Function(function_scope) => find_in_function_by_name(function_scope, name),
Scope::Block(block_scope) => find_in_block_by_name(block_scope, name),
}
}
pub fn insert_symbol(&mut self, symbol: Symbol) {
match symbol {
Symbol::Class(class_symbol) => {
self.insert_class_symbol(class_symbol);
}
Symbol::GenericParameter(generic_parameter_symbol) => {
self.insert_generic_parameter_symbol(generic_parameter_symbol);
}
Symbol::Field(field_symbol) => {
self.insert_field_symbol(field_symbol);
}
Symbol::Constructor(constructor_symbol) => {
self.insert_constructor_symbol(constructor_symbol);
}
Symbol::Function(function_symbol) => {
self.insert_function_symbol(function_symbol);
}
Symbol::Parameter(parameter_symbol) => {
self.insert_parameter_symbol(parameter_symbol);
}
Symbol::Variable(variable_symbol) => {
self.insert_variable_symbol(variable_symbol);
}
}
}
pub fn insert_class_symbol(&mut self, class_symbol: Rc<ClassSymbol>) {
let name = class_symbol.declared_name_owned();
match self.scope_mut(class_symbol.scope_id()) {
Scope::Module(module_scope) => {
find_in_module_by_name(module_scope, class_symbol.declared_name())
module_scope.class_symbols_mut().insert(name, class_symbol);
}
Scope::Class(class_scope) => {
find_in_class_by_name(class_scope, class_symbol.declared_name())
Scope::ClassBody(class_scope) => {
class_scope.class_symbols_mut().insert(name, class_symbol);
}
_ => panic!("Attempt to insert ClassSymbol in incompatible scope"),
};
if let Some(already_inserted) = maybe_already_inserted {
return Err(SymbolInsertError::AlreadyDeclared(AlreadyDeclared::new(
already_inserted,
)));
}
let name = class_symbol.declared_name_owned();
let as_rc = Rc::new(RefCell::new(class_symbol));
let to_return = as_rc.clone();
match self.current_scope_mut() {
Scope::Module(module_scope) => {
module_scope.class_symbols_mut().insert(name, as_rc);
}
Scope::Class(class_scope) => {
class_scope.class_symbols_mut().insert(name, as_rc);
}
_ => unreachable!(),
}
Ok(to_return)
}
pub fn insert_generic_parameter_symbol(
&mut self,
generic_parameter_symbol: GenericParameterSymbol,
) -> Result<Rc<RefCell<GenericParameterSymbol>>, SymbolInsertError> {
let maybe_already_inserted = match self.current_scope() {
Scope::Class(class_scope) => {
find_type_symbol_in_class(class_scope, generic_parameter_symbol.declared_name())
}
_ => panic!("Attempt to insert GenericParameterSymbol in incompatible scope"),
};
if let Some(already_inserted) = maybe_already_inserted {
match already_inserted {
TypeSymbol::Class(class_symbol) => {
return Err(SymbolInsertError::AlreadyDeclared(AlreadyDeclared::new(
class_symbol as Rc<RefCell<dyn Symbol>>,
)));
}
TypeSymbol::GenericParameter(generic_parameter_symbol) => {
return Err(SymbolInsertError::AlreadyDeclared(AlreadyDeclared::new(
generic_parameter_symbol as Rc<RefCell<dyn Symbol>>,
)));
}
}
}
generic_parameter_symbol: Rc<GenericParameterSymbol>,
) {
let name = generic_parameter_symbol.declared_name_owned();
let as_rc = Rc::new(RefCell::new(generic_parameter_symbol));
let to_return = as_rc.clone();
match self.current_scope_mut() {
match self.scope_mut(generic_parameter_symbol.scope_id()) {
Scope::Class(class_scope) => {
class_scope
.generic_parameter_symbols_mut()
.insert(name, as_rc);
.insert(name, generic_parameter_symbol);
}
_ => panic!("Attempt to insert GenericParameterSymbol in incompatible scope"),
}
_ => unreachable!(),
}
Ok(to_return)
pub fn insert_constructor_symbol(&mut self, constructor_symbol: Rc<ConstructorSymbol>) {
match self.scope_mut(constructor_symbol.scope_id()) {
Scope::ClassBody(class_scope) => {
class_scope
.constructor_symbol_mut()
.replace(constructor_symbol);
}
pub fn insert_constructor_symbol(
&mut self,
constructor_symbol: ConstructorSymbol,
) -> Result<Rc<RefCell<ConstructorSymbol>>, SymbolInsertError> {
let maybe_already_inserted = match self.current_scope() {
Scope::Class(class_scope) => class_scope.constructor_symbol(),
_ => panic!("Attempt to insert ConstructorSymbol in incompatible scope"),
};
if let Some(already_inserted) = maybe_already_inserted {
return Err(SymbolInsertError::AlreadyDeclared(AlreadyDeclared::new(
already_inserted.clone() as Rc<RefCell<dyn Symbol>>,
)));
}
}
let as_rc = Rc::new(RefCell::new(constructor_symbol));
let to_return = as_rc.clone();
match self.current_scope_mut() {
Scope::Class(class_scope) => {
class_scope.constructor_symbol_mut().replace(as_rc);
}
_ => unreachable!(),
}
Ok(to_return)
}
pub fn insert_field_symbol(
&mut self,
field_symbol: FieldSymbol,
) -> Result<Rc<RefCell<FieldSymbol>>, SymbolInsertError> {
let maybe_already_inserted = match self.current_scope() {
Scope::Class(class_scope) => {
find_in_class_by_name(class_scope, field_symbol.declared_name())
pub fn insert_field_symbol(&mut self, field_symbol: Rc<FieldSymbol>) {
let name = field_symbol.declared_name_owned();
match self.scope_mut(field_symbol.scope_id()) {
Scope::ClassBody(class_scope) => {
class_scope.field_symbols_mut().insert(name, field_symbol);
}
_ => panic!("Attempt to insert FieldSymbol in incompatible scope"),
};
if let Some(already_inserted) = maybe_already_inserted {
return Err(SymbolInsertError::AlreadyDeclared(AlreadyDeclared::new(
already_inserted,
)));
}
}
let name = field_symbol.declared_name_owned();
let as_rc = Rc::new(RefCell::new(field_symbol));
let to_return = as_rc.clone();
match self.current_scope_mut() {
Scope::Class(class_scope) => {
class_scope.field_symbols_mut().insert(name, as_rc);
}
_ => unreachable!(),
}
Ok(to_return)
}
pub fn insert_function_symbol(
&mut self,
function_symbol: FunctionSymbol,
) -> Result<Rc<RefCell<FunctionSymbol>>, SymbolInsertError> {
let maybe_already_inserted = match self.current_scope() {
pub fn insert_function_symbol(&mut self, function_symbol: Rc<FunctionSymbol>) {
let name = function_symbol.declared_name_owned();
match self.scope_mut(function_symbol.scope_id()) {
Scope::Module(module_scope) => {
find_in_module_by_name(module_scope, function_symbol.declared_name())
module_scope
.function_symbols_mut()
.insert(name, function_symbol);
}
Scope::Class(class_scope) => {
find_in_class_by_name(class_scope, function_symbol.declared_name())
Scope::ClassBody(class_scope) => {
class_scope
.function_symbols_mut()
.insert(name, function_symbol);
}
_ => panic!("Attempt to insert FunctionSymbol in incompatible scope"),
};
if let Some(already_inserted) = maybe_already_inserted {
return Err(SymbolInsertError::AlreadyDeclared(AlreadyDeclared::new(
already_inserted,
)));
}
let name = function_symbol.declared_name_owned();
let as_rc = Rc::new(RefCell::new(function_symbol));
let to_return = as_rc.clone();
match self.current_scope_mut() {
Scope::Module(module_scope) => {
module_scope.function_symbols_mut().insert(name, as_rc);
}
Scope::Class(class_scope) => {
class_scope.function_symbols_mut().insert(name, as_rc);
}
_ => unreachable!(),
}
Ok(to_return)
}
pub fn insert_parameter_symbol(
&mut self,
parameter_symbol: ParameterSymbol,
) -> Result<Rc<RefCell<ParameterSymbol>>, SymbolInsertError> {
let maybe_already_inserted = match self.current_scope() {
Scope::Function(function_scope) => {
find_in_function_by_name(function_scope, parameter_symbol.declared_name())
}
_ => panic!("Attempt to insert ParameterSymbol in incompatible scope"),
};
if let Some(already_inserted) = maybe_already_inserted {
return Err(SymbolInsertError::AlreadyDeclared(AlreadyDeclared::new(
already_inserted,
)));
}
}
pub fn insert_parameter_symbol(&mut self, parameter_symbol: Rc<ParameterSymbol>) {
let name = parameter_symbol.declared_name_owned();
let as_rc = Rc::new(RefCell::new(parameter_symbol));
let to_return = as_rc.clone();
match self.current_scope_mut() {
match self.scope_mut(parameter_symbol.scope_id()) {
Scope::Function(function_scope) => {
function_scope.parameter_symbols_mut().insert(name, as_rc);
function_scope
.parameter_symbols_mut()
.insert(name, parameter_symbol);
}
_ => panic!("Attempt to insert ParameterSymbol in incompatible scope"),
}
Ok(to_return)
}
pub fn insert_variable_symbol(
&mut self,
variable_symbol: VariableSymbol,
) -> Result<(), SymbolInsertError> {
let maybe_already_inserted = match self.current_scope() {
pub fn insert_variable_symbol(&mut self, variable_symbol: Rc<VariableSymbol>) {
match self.scope_mut(variable_symbol.scope_id()) {
Scope::Block(block_scope) => {
find_in_block_by_name(block_scope, variable_symbol.declared_name())
block_scope
.variable_symbols_mut()
.insert(variable_symbol.declared_name_owned(), variable_symbol);
}
_ => panic!("Attempt to insert VariableSymbol in incompatible scope"),
};
if let Some(already_inserted) = maybe_already_inserted {
return Err(SymbolInsertError::AlreadyDeclared(AlreadyDeclared::new(
already_inserted,
)));
}
}
match self.current_scope_mut() {
Scope::Block(block_scope) => {
block_scope.variable_symbols_mut().insert(
variable_symbol.declared_name_owned(),
Rc::new(RefCell::new(variable_symbol)),
);
fn find_symbol<S>(
&self,
scope_id: usize,
name: &str,
f: impl Fn(&Scope, &str) -> Option<S>,
) -> Option<S> {
let mut maybe_scope = self.scopes.get(scope_id);
if maybe_scope.is_none() {
panic!("Invalid scope_id: {}", scope_id);
}
_ => unreachable!(),
while let Some(scope) = maybe_scope {
let maybe_symbol = f(scope, name);
if maybe_symbol.is_some() {
return maybe_symbol;
} else {
maybe_scope = scope.parent_id().and_then(|id| self.scopes.get(id));
}
Ok(())
}
None
}
pub fn find_expressible_symbol(
@ -353,28 +281,82 @@ impl SymbolTable {
None
}
pub fn get_variable_symbol(&self, scope_id: usize, name: &str) -> Rc<RefCell<VariableSymbol>> {
pub fn get_class_symbol(&self, scope_id: usize, name: &str) -> Option<&Rc<ClassSymbol>> {
match self.scope(scope_id) {
Scope::Module(module_scope) => module_scope.class_symbols().get(name),
Scope::ClassBody(class_body_scope) => class_body_scope.class_symbols().get(name),
_ => panic!("scope_id {} cannot contain classes", scope_id),
}
}
pub fn get_field_symbol(&self, scope_id: usize, name: &str) -> Option<&FieldSymbol> {
match self.scope(scope_id) {
Scope::ClassBody(class_body_scope) => {
class_body_scope.field_symbols().get(name).map(Rc::as_ref)
}
_ => panic!("scope_id {} is not a ClassBodyScope", scope_id),
}
}
pub fn get_constructor_symbol(&self, scope_id: usize) -> Option<&ConstructorSymbol> {
match self.scope(scope_id) {
Scope::ClassBody(class_body_scope) => {
class_body_scope.constructor_symbol().map(Rc::as_ref)
}
_ => panic!("scope_id {} is not a ClassBodyScope", scope_id),
}
}
pub fn get_function_symbol(&self, scope_id: usize, name: &str) -> Option<&FunctionSymbol> {
match self.scope(scope_id) {
Scope::Module(module_scope) => {
module_scope.function_symbols().get(name).map(Rc::as_ref)
}
Scope::ClassBody(class_body_scope) => class_body_scope
.function_symbols()
.get(name)
.map(Rc::as_ref),
_ => panic!("scope_id {} cannot contain Functions", scope_id),
}
}
pub fn get_parameter_symbol(&self, scope_id: usize, name: &str) -> Option<&ParameterSymbol> {
match self.scope(scope_id) {
Scope::Function(function_scope) => {
function_scope.parameter_symbols().get(name).map(Rc::as_ref)
}
_ => panic!("scope_id {} cannot contain Parameters", scope_id),
}
}
pub fn get_parameter_symbol_owned(
&self,
scope_id: usize,
name: &str,
) -> Option<Rc<ParameterSymbol>> {
match self.scope(scope_id) {
Scope::Function(function_scope) => {
function_scope.parameter_symbols().get(name).cloned()
}
_ => panic!("scope_id {} cannot contain Parameters", scope_id),
}
}
pub fn get_variable_symbol(&self, scope_id: usize, name: &str) -> Option<&VariableSymbol> {
match &self.scopes[scope_id] {
Scope::Block(block_scope) => block_scope.variable_symbols().get(name).cloned().unwrap(),
Scope::Block(block_scope) => block_scope.variable_symbols().get(name).map(Rc::as_ref),
_ => panic!("scope_id {} is not a BlockScope", scope_id),
}
}
pub fn get_variable_symbol_owned(
&self,
scope_id: usize,
name: &str,
) -> Option<Rc<VariableSymbol>> {
match self.scope(scope_id) {
Scope::Block(block_scope) => block_scope.variable_symbols().get(name).map(Rc::clone),
_ => panic!("scope_id {} is not a BlockScope", scope_id),
}
}
}
pub enum SymbolInsertError {
AlreadyDeclared(AlreadyDeclared),
}
pub struct AlreadyDeclared {
symbol: Rc<RefCell<dyn Symbol>>,
}
impl AlreadyDeclared {
pub fn new(symbol: Rc<RefCell<dyn Symbol>>) -> Self {
Self { symbol }
}
pub fn symbol(&self) -> &Rc<RefCell<dyn Symbol>> {
&self.symbol
}
}

28
dmc-lib/src/type_info.rs
View File

@ -1,10 +1,8 @@
use crate::symbol::Symbol;
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol::generic_parameter_symbol::GenericParameterSymbol;
use crate::symbol::type_symbol::TypeSymbol;
use crate::symbol_table::SymbolTable;
use std::cell::RefCell;
use std::fmt::{Display, Formatter};
use std::rc::Rc;
@ -14,9 +12,9 @@ pub enum TypeInfo {
Integer,
Double,
String,
Function(Rc<RefCell<FunctionSymbol>>),
ClassInstance(Rc<RefCell<ClassSymbol>>),
GenericType(Rc<RefCell<GenericParameterSymbol>>),
Function(Rc<FunctionSymbol>),
ClassInstance(Rc<ClassSymbol>),
GenericType(Rc<GenericParameterSymbol>),
Void,
}
@ -29,16 +27,19 @@ impl Display for TypeInfo {
TypeInfo::String => write!(f, "String"),
TypeInfo::Function(function_symbol) => {
write!(f, "fn(")?;
for parameter in function_symbol.borrow().parameters() {
parameter.borrow().type_info().fmt(f)?;
for (i, parameter) in function_symbol.parameters().iter().enumerate() {
parameter.declared_name().fmt(f)?;
if i < function_symbol.parameters().len() - 1 {
f.write_str(", ")?;
}
}
write!(f, ")")
}
TypeInfo::ClassInstance(class_symbol) => {
write!(f, "{}", class_symbol.borrow().declared_name())
write!(f, "{}", class_symbol.declared_name())
}
TypeInfo::GenericType(generic_parameter_symbol) => {
write!(f, "{}", generic_parameter_symbol.borrow().declared_name())
write!(f, "{}", generic_parameter_symbol.declared_name())
}
TypeInfo::Void => write!(f, "Void"),
}
@ -58,7 +59,7 @@ impl TypeInfo {
declared_name: &str,
scope_id: usize,
symbol_table: &SymbolTable,
class_context: Option<&Rc<RefCell<ClassSymbol>>>,
class_context: Option<&Rc<ClassSymbol>>,
) -> Option<Self> {
match declared_name {
"Any" => Some(TypeInfo::Any),
@ -66,7 +67,7 @@ impl TypeInfo {
"Double" => Some(TypeInfo::Double),
"String" => Some(TypeInfo::String),
"Void" => Some(TypeInfo::Void),
"Self" => Some(TypeInfo::ClassInstance(class_context.unwrap().clone())),
"Self" => Some(TypeInfo::ClassInstance(class_context.cloned().unwrap())),
_ => match symbol_table.find_type_symbol(scope_id, declared_name) {
None => None,
Some(type_symbol) => match type_symbol {
@ -97,14 +98,13 @@ impl TypeInfo {
TypeInfo::ClassInstance(class_symbol) => {
match other {
TypeInfo::ClassInstance(other_class_symbol) => {
class_symbol.borrow().declared_name()
== other_class_symbol.borrow().declared_name() // good enough for now
class_symbol == other_class_symbol // good enough for now
}
_ => false,
}
}
TypeInfo::GenericType(generic_parameter_symbol) => {
if generic_parameter_symbol.borrow().extends().len() > 0 {
if generic_parameter_symbol.extends().len() > 0 {
unimplemented!(
"Assigning to generic parameter type with extends type uses not yet supported."
);

68
dmc-lib/src/types_table.rs Normal file
View File

@ -0,0 +1,68 @@
use crate::symbol::class_symbol::ClassSymbol;
use crate::symbol::field_symbol::FieldSymbol;
use crate::symbol::function_symbol::FunctionSymbol;
use crate::symbol::parameter_symbol::ParameterSymbol;
use crate::symbol::variable_symbol::VariableSymbol;
use crate::type_info::TypeInfo;
use std::collections::HashMap;
use std::rc::Rc;
pub struct TypesTable {
class_instance_types: HashMap<Rc<ClassSymbol>, TypeInfo>,
field_types: HashMap<Rc<FieldSymbol>, TypeInfo>,
parameter_types: HashMap<Rc<ParameterSymbol>, TypeInfo>,
variable_types: HashMap<Rc<VariableSymbol>, TypeInfo>,
function_return_types: HashMap<Rc<FunctionSymbol>, TypeInfo>,
}
impl TypesTable {
pub fn new() -> Self {
Self {
class_instance_types: HashMap::new(),
field_types: HashMap::new(),
parameter_types: HashMap::new(),
variable_types: HashMap::new(),
function_return_types: HashMap::new(),
}
}
pub fn class_instance_types(&self) -> &HashMap<Rc<ClassSymbol>, TypeInfo> {
&self.class_instance_types
}
pub fn class_instance_types_mut(&mut self) -> &mut HashMap<Rc<ClassSymbol>, TypeInfo> {
&mut self.class_instance_types
}
pub fn field_types(&self) -> &HashMap<Rc<FieldSymbol>, TypeInfo> {
&self.field_types
}
pub fn field_types_mut(&mut self) -> &mut HashMap<Rc<FieldSymbol>, TypeInfo> {
&mut self.field_types
}
pub fn parameter_types(&self) -> &HashMap<Rc<ParameterSymbol>, TypeInfo> {
&self.parameter_types
}
pub fn parameter_types_mut(&mut self) -> &mut HashMap<Rc<ParameterSymbol>, TypeInfo> {
&mut self.parameter_types
}
pub fn variable_types(&self) -> &HashMap<Rc<VariableSymbol>, TypeInfo> {
&self.variable_types
}
pub fn variable_types_mut(&mut self) -> &mut HashMap<Rc<VariableSymbol>, TypeInfo> {
&mut self.variable_types
}
pub fn function_return_types(&self) -> &HashMap<Rc<FunctionSymbol>, TypeInfo> {
&self.function_return_types
}
pub fn function_return_types_mut(&mut self) -> &mut HashMap<Rc<FunctionSymbol>, TypeInfo> {
&mut self.function_return_types
}
}

96
e2e-tests/src/lib.rs
View File

@ -4,6 +4,7 @@ mod e2e_tests {
use dmc_lib::diagnostic::Diagnostic;
use dmc_lib::parser::parse_compilation_unit;
use dmc_lib::symbol_table::SymbolTable;
use dmc_lib::types_table::TypesTable;
use dvm_lib::vm::class::Class;
use dvm_lib::vm::constant::{Constant, StringConstant};
use dvm_lib::vm::function::Function;
@ -26,7 +27,7 @@ mod e2e_tests {
panic!("There were diagnostics.");
}
fn prepare_context(input: &str) -> DvmContext {
fn prepare_context(input: &str) -> Result<DvmContext, Vec<Diagnostic>> {
let parse_result = parse_compilation_unit(input);
let mut compilation_unit = match parse_result {
Ok(compilation_unit) => compilation_unit,
@ -36,29 +37,14 @@ mod e2e_tests {
};
let mut symbol_table = SymbolTable::new();
let mut types_table = TypesTable::new();
match compilation_unit.gather_declared_names(&mut symbol_table) {
Ok(_) => {}
Err(diagnostics) => {
report_diagnostics(&diagnostics);
}
}
compilation_unit.init_scopes(&mut symbol_table);
compilation_unit.gather_symbols_into(&mut symbol_table)?;
compilation_unit.check_names(&mut symbol_table)?;
compilation_unit.type_check(&symbol_table, &mut types_table)?;
match compilation_unit.check_name_usages(&symbol_table) {
Ok(_) => {}
Err(diagnostics) => {
report_diagnostics(&diagnostics);
}
}
match compilation_unit.type_check(&symbol_table) {
Ok(_) => {}
Err(diagnostics) => {
report_diagnostics(&diagnostics);
}
}
let (ir_classes, mut ir_functions) = compilation_unit.to_ir(&symbol_table);
let (ir_classes, mut ir_functions) = compilation_unit.to_ir(&symbol_table, &types_table);
let mut functions: Vec<Function> = vec![];
let mut constants_table = ConstantsTable::new();
@ -95,7 +81,7 @@ mod e2e_tests {
);
}
dvm_context
Ok(dvm_context)
}
fn get_result(
@ -116,7 +102,10 @@ mod e2e_tests {
}
fn assert_result(input: &str, function_name: &str, arguments: &[Value], expected_value: Value) {
let context = prepare_context(input);
let context = match prepare_context(input) {
Ok(context) => context,
Err(diagnostics) => report_diagnostics(&diagnostics),
};
match get_result(&context, function_name, arguments) {
None => panic!("Call returned no value"),
Some(result_value) => {
@ -215,7 +204,7 @@ mod e2e_tests {
}
#[test]
fn two_classes() {
fn two_classes() -> Result<(), Vec<Diagnostic>> {
let context = prepare_context(
"
class Foo
@ -239,7 +228,7 @@ mod e2e_tests {
Foo(n)
end
",
);
)?;
let result = get_result(&context, "foo", &[Value::Int(42)]);
assert!(result.is_some());
let value = result.unwrap();
@ -247,6 +236,7 @@ mod e2e_tests {
let o = value.unwrap_object().borrow();
assert_eq!(o.fields().len(), 1);
assert_eq!(o.fields()[0].unwrap_int(), 42);
Ok(())
}
#[test]
@ -266,7 +256,7 @@ mod e2e_tests {
}
#[test]
fn assign_field() {
fn assign_field() -> Result<(), Vec<Diagnostic>> {
let context = prepare_context(
"
class Foo
@ -281,7 +271,7 @@ mod e2e_tests {
Foo(42)
end
",
);
)?;
let result = get_result(&context, "foo", &vec![]);
assert!(result.is_some());
let value = result.unwrap();
@ -289,10 +279,11 @@ mod e2e_tests {
let o = value.unwrap_object().borrow();
assert_eq!(o.fields().len(), 1);
assert_eq!(o.fields()[0].unwrap_int(), 42);
Ok(())
}
#[test]
fn see_what_happens() {
fn see_what_happens() -> Result<(), Vec<Diagnostic>> {
let context = prepare_context(
"
class Foo<T>
@ -306,7 +297,7 @@ mod e2e_tests {
Foo(42)
end
",
);
)?;
let result = get_result(&context, "main", &vec![]);
assert!(result.is_some());
let value = result.unwrap();
@ -314,49 +305,6 @@ mod e2e_tests {
let o = value.unwrap_object().borrow();
assert_eq!(o.fields().len(), 1);
assert_eq!(o.fields()[0].unwrap_int(), 42);
}
}
#[cfg(test)]
mod diagnostic_tests {
use dmc_lib::diagnostic::Diagnostic;
use dmc_lib::parser::parse_compilation_unit;
use dmc_lib::symbol_table::SymbolTable;
fn get_diagnostics(input: &str) -> Vec<Diagnostic> {
let parse_result = parse_compilation_unit(input);
let mut compilation_unit = match parse_result {
Ok(compilation_unit) => compilation_unit,
Err(diagnostics) => {
return diagnostics;
}
};
let mut symbol_table = SymbolTable::new();
match compilation_unit.gather_declared_names(&mut symbol_table) {
Ok(_) => {}
Err(diagnostics) => {
return diagnostics;
}
}
match compilation_unit.check_name_usages(&symbol_table) {
Ok(_) => {}
Err(diagnostics) => {
return diagnostics;
}
}
match compilation_unit.type_check(&symbol_table) {
Ok(_) => vec![],
Err(diagnostics) => diagnostics,
}
}
#[test]
fn wrong_return_type() {
let diagnostics = get_diagnostics("fn main() -> String 42 end");
assert_eq!(diagnostics.len(), 1);
Ok(())
}
}