2252 lines
73 KiB
Rust
2252 lines
73 KiB
Rust
//! Compilation tools and errors
|
|
//!
|
|
//! This module provides two compilation options:
|
|
//! - [`compile`], which compiles the entire input and returns a chunk
|
|
//! - [`Compiler`], which compiles the input a token at a time while assembling a chunk
|
|
use std::{
|
|
fmt::{self, Display, Formatter},
|
|
mem::replace,
|
|
num::{ParseFloatError, ParseIntError},
|
|
vec,
|
|
};
|
|
|
|
use colored::Colorize;
|
|
|
|
use crate::{
|
|
value::ConcreteValue, AnnotatedError, Chunk, ChunkError, DustError, FunctionType, Instruction,
|
|
LexError, Lexer, Local, NativeFunction, Operation, Optimizer, Scope, Span, Token, TokenKind,
|
|
TokenOwned, Type, TypeConflict,
|
|
};
|
|
|
|
/// Compiles the input and returns a chunk.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use dust_lang::compile;
|
|
/// let source = "40 + 2 == 42";
|
|
/// let chunk = compile(source).unwrap();
|
|
///
|
|
/// assert_eq!(chunk.len(), 6);
|
|
/// ```
|
|
pub fn compile(source: &str) -> Result<Chunk, DustError> {
|
|
let lexer = Lexer::new(source);
|
|
let mut compiler =
|
|
Compiler::new(lexer).map_err(|error| DustError::Compile { error, source })?;
|
|
|
|
compiler
|
|
.parse_top_level()
|
|
.map_err(|error| DustError::Compile { error, source })?;
|
|
|
|
Ok(compiler.finish())
|
|
}
|
|
|
|
/// Low-level tool for compiling the input a token at a time while assembling a chunk.
|
|
///
|
|
/// See the [`compile`] function an example of how to create and use a Compiler.
|
|
#[derive(Debug, Eq, PartialEq, PartialOrd)]
|
|
pub struct Compiler<'src> {
|
|
chunk: Chunk,
|
|
lexer: Lexer<'src>,
|
|
|
|
current_token: Token<'src>,
|
|
current_position: Span,
|
|
|
|
previous_token: Token<'src>,
|
|
previous_position: Span,
|
|
|
|
return_type: Option<Type>,
|
|
local_definitions: Vec<u8>,
|
|
optimization_count: usize,
|
|
previous_expression_type: Type,
|
|
minimum_register: u8,
|
|
|
|
block_index: u8,
|
|
current_scope: Scope,
|
|
}
|
|
|
|
impl<'src> Compiler<'src> {
|
|
pub fn new(mut lexer: Lexer<'src>) -> Result<Self, CompileError> {
|
|
let (current_token, current_position) = lexer.next_token()?;
|
|
let chunk = Chunk::new(None);
|
|
|
|
log::info!(
|
|
"Begin chunk with {} at {}",
|
|
current_token.to_string().bold(),
|
|
current_position.to_string()
|
|
);
|
|
|
|
Ok(Compiler {
|
|
chunk,
|
|
lexer,
|
|
current_token,
|
|
current_position,
|
|
previous_token: Token::Eof,
|
|
previous_position: Span(0, 0),
|
|
return_type: None,
|
|
local_definitions: Vec::new(),
|
|
optimization_count: 0,
|
|
previous_expression_type: Type::None,
|
|
minimum_register: 0,
|
|
block_index: 0,
|
|
current_scope: Scope::default(),
|
|
})
|
|
}
|
|
|
|
pub fn finish(mut self) -> Chunk {
|
|
log::info!("End chunk with {} optimizations", self.optimization_count);
|
|
|
|
if let Type::None = *self.chunk.r#type().return_type {
|
|
self.chunk.set_type(FunctionType {
|
|
type_parameters: None,
|
|
value_parameters: None,
|
|
return_type: self
|
|
.return_type
|
|
.map_or_else(|| Box::new(Type::None), Box::new),
|
|
});
|
|
}
|
|
|
|
self.chunk
|
|
}
|
|
|
|
fn is_eof(&self) -> bool {
|
|
matches!(self.current_token, Token::Eof)
|
|
}
|
|
|
|
fn next_register(&mut self) -> u8 {
|
|
self.chunk
|
|
.instructions()
|
|
.iter()
|
|
.rev()
|
|
.find_map(|(instruction, _)| {
|
|
if instruction.yields_value() {
|
|
let previous = instruction.a();
|
|
let next = previous.overflowing_add(1).0;
|
|
|
|
Some(next)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.unwrap_or(self.minimum_register)
|
|
}
|
|
|
|
fn advance(&mut self) -> Result<(), CompileError> {
|
|
if self.is_eof() {
|
|
return Ok(());
|
|
}
|
|
|
|
let (new_token, position) = self.lexer.next_token()?;
|
|
|
|
log::info!(
|
|
"Parsing {} at {}",
|
|
new_token.to_string().bold(),
|
|
position.to_string()
|
|
);
|
|
|
|
self.previous_token = replace(&mut self.current_token, new_token);
|
|
self.previous_position = replace(&mut self.current_position, position);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn get_local(&self, index: u8) -> Result<&Local, CompileError> {
|
|
self.chunk
|
|
.get_local(index)
|
|
.map_err(|error| CompileError::Chunk {
|
|
error,
|
|
position: self.current_position,
|
|
})
|
|
}
|
|
|
|
fn get_local_index(&self, identifier_text: &str) -> Result<u8, CompileError> {
|
|
self.chunk
|
|
.locals()
|
|
.iter()
|
|
.enumerate()
|
|
.rev()
|
|
.find_map(|(index, local)| {
|
|
let constant = self
|
|
.chunk
|
|
.constants()
|
|
.get(local.identifier_index as usize)?;
|
|
let identifier = if let ConcreteValue::String(identifier) = constant {
|
|
identifier
|
|
} else {
|
|
return None;
|
|
};
|
|
|
|
if identifier == identifier_text {
|
|
Some(index as u8)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.ok_or(CompileError::UndeclaredVariable {
|
|
identifier: identifier_text.to_string(),
|
|
position: self.current_position,
|
|
})
|
|
}
|
|
|
|
fn declare_local(
|
|
&mut self,
|
|
identifier: &str,
|
|
r#type: Type,
|
|
is_mutable: bool,
|
|
scope: Scope,
|
|
register_index: u8,
|
|
) -> (u8, u8) {
|
|
log::debug!("Declare local {identifier}");
|
|
|
|
let identifier = ConcreteValue::string(identifier);
|
|
let identifier_index = self.chunk.push_or_get_constant(identifier);
|
|
let local_index = self.chunk.locals().len() as u8;
|
|
|
|
self.chunk
|
|
.locals_mut()
|
|
.push(Local::new(identifier_index, r#type, is_mutable, scope));
|
|
self.local_definitions.push(register_index);
|
|
|
|
(local_index, identifier_index)
|
|
}
|
|
|
|
fn allow(&mut self, allowed: Token) -> Result<bool, CompileError> {
|
|
if self.current_token == allowed {
|
|
self.advance()?;
|
|
|
|
Ok(true)
|
|
} else {
|
|
Ok(false)
|
|
}
|
|
}
|
|
|
|
fn expect(&mut self, expected: Token) -> Result<(), CompileError> {
|
|
if self.current_token == expected {
|
|
self.advance()
|
|
} else {
|
|
Err(CompileError::ExpectedToken {
|
|
expected: expected.kind(),
|
|
found: self.current_token.to_owned(),
|
|
position: self.current_position,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn pop_last_instruction(&mut self) -> Result<(Instruction, Span), CompileError> {
|
|
self.chunk
|
|
.instructions_mut()
|
|
.pop()
|
|
.ok_or_else(|| CompileError::ExpectedExpression {
|
|
found: self.previous_token.to_owned(),
|
|
position: self.previous_position,
|
|
})
|
|
}
|
|
|
|
fn get_last_operations<const COUNT: usize>(&self) -> Option<[Operation; COUNT]> {
|
|
let mut n_operations = [Operation::Return; COUNT];
|
|
|
|
for (nth, operation) in n_operations.iter_mut().rev().zip(
|
|
self.chunk
|
|
.instructions()
|
|
.iter()
|
|
.rev()
|
|
.map(|(instruction, _)| instruction.operation()),
|
|
) {
|
|
*nth = operation;
|
|
}
|
|
|
|
Some(n_operations)
|
|
}
|
|
|
|
fn get_last_jumpable_mut_between(
|
|
&mut self,
|
|
minimum: usize,
|
|
maximum: usize,
|
|
) -> Option<&mut Instruction> {
|
|
self.chunk
|
|
.instructions_mut()
|
|
.iter_mut()
|
|
.rev()
|
|
.skip(minimum)
|
|
.take(maximum)
|
|
.find_map(|(instruction, _)| {
|
|
if let Operation::LoadBoolean | Operation::LoadConstant = instruction.operation() {
|
|
Some(instruction)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
}
|
|
|
|
pub fn get_instruction_type(&self, instruction: &Instruction) -> Result<Type, CompileError> {
|
|
use Operation::*;
|
|
|
|
match instruction.operation() {
|
|
Add | Divide | Modulo | Multiply | Subtract => {
|
|
if instruction.b_is_constant() {
|
|
self.chunk
|
|
.get_constant_type(instruction.b())
|
|
.map_err(|error| CompileError::Chunk {
|
|
error,
|
|
position: self.current_position,
|
|
})
|
|
} else {
|
|
self.get_register_type(instruction.b())
|
|
}
|
|
}
|
|
LoadBoolean | Not => Ok(Type::Boolean),
|
|
Negate => {
|
|
if instruction.b_is_constant() {
|
|
self.chunk
|
|
.get_constant_type(instruction.b())
|
|
.map_err(|error| CompileError::Chunk {
|
|
error,
|
|
position: self.current_position,
|
|
})
|
|
} else {
|
|
self.get_register_type(instruction.b())
|
|
}
|
|
}
|
|
LoadConstant => self
|
|
.chunk
|
|
.get_constant_type(instruction.b())
|
|
.map_err(|error| CompileError::Chunk {
|
|
error,
|
|
position: self.current_position,
|
|
}),
|
|
LoadList => self.get_register_type(instruction.a()),
|
|
LoadSelf => Ok(Type::SelfChunk),
|
|
GetLocal => self
|
|
.chunk
|
|
.get_local_type(instruction.b())
|
|
.cloned()
|
|
.map_err(|error| CompileError::Chunk {
|
|
error,
|
|
position: self.current_position,
|
|
}),
|
|
Call => {
|
|
let function_register = instruction.b();
|
|
let function_type = self.get_register_type(function_register)?;
|
|
|
|
match function_type {
|
|
Type::Function(FunctionType { return_type, .. }) => Ok(*return_type),
|
|
Type::SelfChunk => {
|
|
let return_type = self
|
|
.return_type
|
|
.as_ref()
|
|
.unwrap_or_else(|| &self.chunk.r#type().return_type);
|
|
|
|
Ok(return_type.clone())
|
|
}
|
|
_ => Err(CompileError::ExpectedFunctionType {
|
|
found: function_type,
|
|
position: self.current_position,
|
|
}),
|
|
}
|
|
}
|
|
CallNative => {
|
|
let native_function = NativeFunction::from(instruction.b());
|
|
|
|
Ok(*native_function.r#type().return_type)
|
|
}
|
|
_ => Ok(Type::None),
|
|
}
|
|
}
|
|
|
|
pub fn get_register_type(&self, register_index: u8) -> Result<Type, CompileError> {
|
|
for (index, (instruction, _)) in self.chunk.instructions().iter().enumerate() {
|
|
if instruction.a() == register_index {
|
|
if let Operation::LoadList = instruction.operation() {
|
|
let mut length = (instruction.c() - instruction.b() + 1) as usize;
|
|
let mut item_type = Type::Any;
|
|
let distance_to_end = self.chunk.len() - index;
|
|
|
|
for (instruction, _) in self
|
|
.chunk
|
|
.instructions()
|
|
.iter()
|
|
.rev()
|
|
.skip(distance_to_end)
|
|
.take(length)
|
|
{
|
|
if let Operation::Close = instruction.operation() {
|
|
length -= (instruction.c() - instruction.b()) as usize;
|
|
} else if let Type::Any = item_type {
|
|
item_type = self.get_instruction_type(instruction)?;
|
|
}
|
|
}
|
|
|
|
return Ok(Type::List {
|
|
item_type: Box::new(item_type),
|
|
length,
|
|
});
|
|
}
|
|
|
|
if let Operation::LoadSelf = instruction.operation() {
|
|
return Ok(Type::SelfChunk);
|
|
}
|
|
|
|
if instruction.yields_value() {
|
|
return self.get_instruction_type(instruction);
|
|
}
|
|
}
|
|
}
|
|
|
|
Err(CompileError::CannotResolveRegisterType {
|
|
register_index: register_index as usize,
|
|
position: self.current_position,
|
|
})
|
|
}
|
|
|
|
/// Updates [Self::return_type] with the given [Type].
|
|
///
|
|
/// If [Self::return_type] is already set, it will check if the given [Type] is compatible with
|
|
/// it and set it to the least restrictive of the two.
|
|
fn update_return_type(&mut self, new_return_type: Type) -> Result<(), CompileError> {
|
|
if let Some(return_type) = &self.return_type {
|
|
return_type.check(&new_return_type).map_err(|conflict| {
|
|
CompileError::ReturnTypeConflict {
|
|
conflict,
|
|
position: self.current_position,
|
|
}
|
|
})?;
|
|
|
|
if *return_type != Type::Any {
|
|
self.return_type = Some(new_return_type);
|
|
};
|
|
} else {
|
|
self.return_type = Some(new_return_type);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn emit_instruction(&mut self, instruction: Instruction, position: Span) {
|
|
log::debug!(
|
|
"Emitting {} at {}",
|
|
instruction.operation().to_string().bold(),
|
|
position.to_string()
|
|
);
|
|
|
|
self.chunk.instructions_mut().push((instruction, position));
|
|
}
|
|
|
|
fn emit_constant(
|
|
&mut self,
|
|
constant: ConcreteValue,
|
|
position: Span,
|
|
) -> Result<(), CompileError> {
|
|
let constant_index = self.chunk.push_or_get_constant(constant);
|
|
let register = self.next_register();
|
|
|
|
self.emit_instruction(
|
|
Instruction::load_constant(register, constant_index, false),
|
|
position,
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_boolean(&mut self) -> Result<(), CompileError> {
|
|
let position = self.current_position;
|
|
|
|
if let Token::Boolean(text) = self.current_token {
|
|
self.advance()?;
|
|
|
|
let boolean = text.parse::<bool>().unwrap();
|
|
let register = self.next_register();
|
|
|
|
self.emit_instruction(
|
|
Instruction::load_boolean(register, boolean, false),
|
|
position,
|
|
);
|
|
|
|
self.previous_expression_type = Type::Boolean;
|
|
|
|
Ok(())
|
|
} else {
|
|
Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::Boolean,
|
|
found: self.current_token.to_owned(),
|
|
position,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn parse_byte(&mut self) -> Result<(), CompileError> {
|
|
let position = self.current_position;
|
|
|
|
if let Token::Byte(text) = self.current_token {
|
|
self.advance()?;
|
|
|
|
let byte = u8::from_str_radix(&text[2..], 16)
|
|
.map_err(|error| CompileError::ParseIntError { error, position })?;
|
|
let value = ConcreteValue::Byte(byte);
|
|
|
|
self.emit_constant(value, position)?;
|
|
|
|
self.previous_expression_type = Type::Byte;
|
|
|
|
Ok(())
|
|
} else {
|
|
Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::Byte,
|
|
found: self.current_token.to_owned(),
|
|
position,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn parse_character(&mut self) -> Result<(), CompileError> {
|
|
let position = self.current_position;
|
|
|
|
if let Token::Character(character) = self.current_token {
|
|
self.advance()?;
|
|
|
|
let value = ConcreteValue::Character(character);
|
|
|
|
self.emit_constant(value, position)?;
|
|
|
|
self.previous_expression_type = Type::Character;
|
|
|
|
Ok(())
|
|
} else {
|
|
Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::Character,
|
|
found: self.current_token.to_owned(),
|
|
position,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn parse_float(&mut self) -> Result<(), CompileError> {
|
|
let position = self.current_position;
|
|
|
|
if let Token::Float(text) = self.current_token {
|
|
self.advance()?;
|
|
|
|
let float = text
|
|
.parse::<f64>()
|
|
.map_err(|error| CompileError::ParseFloatError {
|
|
error,
|
|
position: self.previous_position,
|
|
})?;
|
|
let value = ConcreteValue::Float(float);
|
|
|
|
self.emit_constant(value, position)?;
|
|
|
|
self.previous_expression_type = Type::Float;
|
|
|
|
Ok(())
|
|
} else {
|
|
Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::Float,
|
|
found: self.current_token.to_owned(),
|
|
position,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn parse_integer(&mut self) -> Result<(), CompileError> {
|
|
let position = self.current_position;
|
|
|
|
if let Token::Integer(text) = self.current_token {
|
|
self.advance()?;
|
|
|
|
let integer = text
|
|
.parse::<i64>()
|
|
.map_err(|error| CompileError::ParseIntError {
|
|
error,
|
|
position: self.previous_position,
|
|
})?;
|
|
let value = ConcreteValue::Integer(integer);
|
|
|
|
self.emit_constant(value, position)?;
|
|
|
|
self.previous_expression_type = Type::Integer;
|
|
|
|
Ok(())
|
|
} else {
|
|
Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::Integer,
|
|
found: self.current_token.to_owned(),
|
|
position,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn parse_string(&mut self) -> Result<(), CompileError> {
|
|
let position = self.current_position;
|
|
|
|
if let Token::String(text) = self.current_token {
|
|
self.advance()?;
|
|
|
|
let value = ConcreteValue::string(text);
|
|
|
|
self.emit_constant(value, position)?;
|
|
|
|
self.previous_expression_type = Type::String {
|
|
length: Some(text.len()),
|
|
};
|
|
|
|
Ok(())
|
|
} else {
|
|
Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::String,
|
|
found: self.current_token.to_owned(),
|
|
position,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn parse_grouped(&mut self) -> Result<(), CompileError> {
|
|
self.allow(Token::LeftParenthesis)?;
|
|
self.parse_expression()?;
|
|
self.expect(Token::RightParenthesis)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_unary(&mut self) -> Result<(), CompileError> {
|
|
let operator = self.current_token;
|
|
let operator_position = self.current_position;
|
|
|
|
self.advance()?;
|
|
self.parse_expression()?;
|
|
|
|
let (previous_instruction, previous_position) = self.pop_last_instruction()?;
|
|
let (push_back, is_constant, argument) = {
|
|
match previous_instruction.operation() {
|
|
Operation::GetLocal => (false, false, previous_instruction.a()),
|
|
Operation::LoadConstant => (false, true, previous_instruction.a()),
|
|
Operation::LoadBoolean => (true, false, previous_instruction.a()),
|
|
Operation::Close => {
|
|
return Err(CompileError::ExpectedExpression {
|
|
found: self.previous_token.to_owned(),
|
|
position: self.previous_position,
|
|
});
|
|
}
|
|
_ => (true, false, previous_instruction.a()),
|
|
}
|
|
};
|
|
|
|
if push_back {
|
|
self.emit_instruction(previous_instruction, previous_position);
|
|
}
|
|
|
|
let register = self.next_register();
|
|
let mut instruction = match operator.kind() {
|
|
TokenKind::Bang => Instruction::not(register, argument),
|
|
TokenKind::Minus => Instruction::negate(register, argument),
|
|
_ => {
|
|
return Err(CompileError::ExpectedTokenMultiple {
|
|
expected: &[TokenKind::Bang, TokenKind::Minus],
|
|
found: operator.to_owned(),
|
|
position: operator_position,
|
|
})
|
|
}
|
|
};
|
|
|
|
if is_constant {
|
|
instruction.set_b_is_constant();
|
|
}
|
|
|
|
self.emit_instruction(instruction, operator_position);
|
|
|
|
if let TokenKind::Bang = operator.kind() {
|
|
self.previous_expression_type = Type::Boolean;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_binary_argument(
|
|
&mut self,
|
|
instruction: &Instruction,
|
|
) -> Result<(bool, bool, bool, u8), CompileError> {
|
|
let mut push_back = false;
|
|
let mut is_constant = false;
|
|
let mut is_mutable_local = false;
|
|
let argument = match instruction.operation() {
|
|
Operation::GetLocal => {
|
|
let local_index = instruction.b();
|
|
let local = self.get_local(local_index)?;
|
|
is_mutable_local = local.is_mutable;
|
|
|
|
*self
|
|
.local_definitions
|
|
.get(local_index as usize)
|
|
.ok_or_else(|| {
|
|
let identifier = self
|
|
.chunk
|
|
.constants()
|
|
.get(local.identifier_index as usize)
|
|
.unwrap()
|
|
.to_string();
|
|
|
|
CompileError::UndeclaredVariable {
|
|
identifier,
|
|
position: self.current_position,
|
|
}
|
|
})?
|
|
}
|
|
Operation::LoadConstant => {
|
|
is_constant = true;
|
|
|
|
instruction.b()
|
|
}
|
|
Operation::Close => {
|
|
return Err(CompileError::ExpectedExpression {
|
|
found: self.previous_token.to_owned(),
|
|
position: self.previous_position,
|
|
});
|
|
}
|
|
_ => {
|
|
push_back = true;
|
|
|
|
if instruction.yields_value() {
|
|
instruction.a()
|
|
} else {
|
|
self.next_register()
|
|
}
|
|
}
|
|
};
|
|
|
|
Ok((push_back, is_constant, is_mutable_local, argument))
|
|
}
|
|
|
|
fn parse_math_binary(&mut self) -> Result<(), CompileError> {
|
|
let (left_instruction, left_position) =
|
|
self.chunk.instructions_mut().pop().ok_or_else(|| {
|
|
CompileError::ExpectedExpression {
|
|
found: self.previous_token.to_owned(),
|
|
position: self.previous_position,
|
|
}
|
|
})?;
|
|
let (push_back_left, left_is_constant, left_is_mutable_local, left) =
|
|
self.handle_binary_argument(&left_instruction)?;
|
|
|
|
if push_back_left {
|
|
self.emit_instruction(left_instruction, left_position);
|
|
}
|
|
|
|
let operator = self.current_token;
|
|
let operator_position = self.current_position;
|
|
let rule = ParseRule::from(&operator);
|
|
|
|
if let Token::PlusEqual | Token::MinusEqual | Token::StarEqual | Token::SlashEqual =
|
|
operator
|
|
{
|
|
if !left_is_mutable_local {
|
|
return Err(CompileError::ExpectedMutableVariable {
|
|
found: self.previous_token.to_owned(),
|
|
position: left_position,
|
|
});
|
|
}
|
|
}
|
|
|
|
self.advance()?;
|
|
self.parse_sub_expression(&rule.precedence)?;
|
|
|
|
let (right_instruction, right_position) = self.pop_last_instruction()?;
|
|
let (push_back_right, right_is_constant, _, right) =
|
|
self.handle_binary_argument(&right_instruction)?;
|
|
|
|
if push_back_right {
|
|
self.emit_instruction(right_instruction, right_position);
|
|
}
|
|
|
|
let register = if left_is_mutable_local {
|
|
left
|
|
} else {
|
|
self.next_register()
|
|
};
|
|
|
|
let mut new_instruction = match operator {
|
|
Token::Plus => Instruction::add(register, left, right),
|
|
Token::PlusEqual => Instruction::add(register, left, right),
|
|
Token::Minus => Instruction::subtract(register, left, right),
|
|
Token::MinusEqual => Instruction::subtract(register, left, right),
|
|
Token::Star => Instruction::multiply(register, left, right),
|
|
Token::StarEqual => Instruction::multiply(register, left, right),
|
|
Token::Slash => Instruction::divide(register, left, right),
|
|
Token::SlashEqual => Instruction::divide(register, left, right),
|
|
Token::Percent => Instruction::modulo(register, left, right),
|
|
Token::PercentEqual => Instruction::modulo(register, left, right),
|
|
_ => {
|
|
return Err(CompileError::ExpectedTokenMultiple {
|
|
expected: &[
|
|
TokenKind::Plus,
|
|
TokenKind::PlusEqual,
|
|
TokenKind::Minus,
|
|
TokenKind::MinusEqual,
|
|
TokenKind::Star,
|
|
TokenKind::StarEqual,
|
|
TokenKind::Slash,
|
|
TokenKind::SlashEqual,
|
|
TokenKind::Percent,
|
|
TokenKind::PercentEqual,
|
|
],
|
|
found: operator.to_owned(),
|
|
position: operator_position,
|
|
})
|
|
}
|
|
};
|
|
|
|
if left_is_constant {
|
|
new_instruction.set_b_is_constant();
|
|
}
|
|
|
|
if right_is_constant {
|
|
new_instruction.set_c_is_constant();
|
|
}
|
|
|
|
self.emit_instruction(new_instruction, operator_position);
|
|
|
|
if let Token::PlusEqual
|
|
| Token::MinusEqual
|
|
| Token::StarEqual
|
|
| Token::SlashEqual
|
|
| Token::PercentEqual = operator
|
|
{
|
|
self.previous_expression_type = Type::None;
|
|
} else {
|
|
self.previous_expression_type = self.get_instruction_type(&left_instruction)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_comparison_binary(&mut self) -> Result<(), CompileError> {
|
|
if let Some([Operation::Equal | Operation::Less | Operation::LessEqual, _, _, _]) =
|
|
self.get_last_operations()
|
|
{
|
|
return Err(CompileError::CannotChainComparison {
|
|
position: self.current_position,
|
|
});
|
|
}
|
|
|
|
let (left_instruction, left_position) =
|
|
self.chunk.instructions_mut().pop().ok_or_else(|| {
|
|
CompileError::ExpectedExpression {
|
|
found: self.previous_token.to_owned(),
|
|
position: self.previous_position,
|
|
}
|
|
})?;
|
|
let (push_back_left, left_is_constant, _, left) =
|
|
self.handle_binary_argument(&left_instruction)?;
|
|
|
|
let operator = self.current_token;
|
|
let operator_position = self.current_position;
|
|
let rule = ParseRule::from(&operator);
|
|
|
|
self.advance()?;
|
|
self.parse_sub_expression(&rule.precedence)?;
|
|
|
|
let (right_instruction, right_position) =
|
|
self.chunk.instructions_mut().pop().ok_or_else(|| {
|
|
CompileError::ExpectedExpression {
|
|
found: self.previous_token.to_owned(),
|
|
position: self.previous_position,
|
|
}
|
|
})?;
|
|
let (push_back_right, right_is_constant, _, right) =
|
|
self.handle_binary_argument(&right_instruction)?;
|
|
|
|
let mut instruction = match operator {
|
|
Token::DoubleEqual => Instruction::equal(true, left, right),
|
|
Token::BangEqual => Instruction::equal(false, left, right),
|
|
Token::Less => Instruction::less(true, left, right),
|
|
Token::LessEqual => Instruction::less_equal(true, left, right),
|
|
Token::Greater => Instruction::less_equal(false, left, right),
|
|
Token::GreaterEqual => Instruction::less(false, left, right),
|
|
_ => {
|
|
return Err(CompileError::ExpectedTokenMultiple {
|
|
expected: &[
|
|
TokenKind::DoubleEqual,
|
|
TokenKind::BangEqual,
|
|
TokenKind::Less,
|
|
TokenKind::LessEqual,
|
|
TokenKind::Greater,
|
|
TokenKind::GreaterEqual,
|
|
],
|
|
found: operator.to_owned(),
|
|
position: operator_position,
|
|
})
|
|
}
|
|
};
|
|
|
|
if left_is_constant {
|
|
instruction.set_b_is_constant();
|
|
}
|
|
|
|
if right_is_constant {
|
|
instruction.set_c_is_constant();
|
|
}
|
|
|
|
if push_back_left {
|
|
self.emit_instruction(left_instruction, left_position);
|
|
}
|
|
|
|
if push_back_right {
|
|
self.emit_instruction(right_instruction, right_position);
|
|
}
|
|
|
|
let register = self.next_register();
|
|
|
|
self.emit_instruction(instruction, operator_position);
|
|
self.emit_instruction(Instruction::jump(1, true), operator_position);
|
|
self.emit_instruction(
|
|
Instruction::load_boolean(register, true, true),
|
|
operator_position,
|
|
);
|
|
self.emit_instruction(
|
|
Instruction::load_boolean(register, false, false),
|
|
operator_position,
|
|
);
|
|
|
|
self.previous_expression_type = Type::Boolean;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_logical_binary(&mut self) -> Result<(), CompileError> {
|
|
let start_length = self.chunk.len();
|
|
let (left_instruction, left_position) = self.pop_last_instruction()?;
|
|
let operator = self.current_token;
|
|
let operator_position = self.current_position;
|
|
let rule = ParseRule::from(&operator);
|
|
|
|
let test_instruction = match operator {
|
|
Token::DoubleAmpersand => Instruction::test(left_instruction.a(), false),
|
|
Token::DoublePipe => Instruction::test(left_instruction.a(), true),
|
|
_ => {
|
|
return Err(CompileError::ExpectedTokenMultiple {
|
|
expected: &[TokenKind::DoubleAmpersand, TokenKind::DoublePipe],
|
|
found: operator.to_owned(),
|
|
position: operator_position,
|
|
})
|
|
}
|
|
};
|
|
|
|
self.advance()?;
|
|
self.emit_instruction(left_instruction, left_position);
|
|
self.emit_instruction(test_instruction, operator_position);
|
|
|
|
let jump_distance = (self.chunk.len() - start_length) as u8;
|
|
|
|
self.emit_instruction(Instruction::jump(jump_distance, true), operator_position);
|
|
self.parse_sub_expression(&rule.precedence)?;
|
|
|
|
self.previous_expression_type = Type::Boolean;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_variable(&mut self) -> Result<(), CompileError> {
|
|
let start_position = self.current_position;
|
|
let identifier = if let Token::Identifier(text) = self.current_token {
|
|
self.advance()?;
|
|
|
|
text
|
|
} else {
|
|
return Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::Identifier,
|
|
found: self.current_token.to_owned(),
|
|
position: start_position,
|
|
});
|
|
};
|
|
let local_index = if let Ok(local_index) = self.get_local_index(identifier) {
|
|
local_index
|
|
} else if let Some(native_function) = NativeFunction::from_str(identifier) {
|
|
return self.parse_native_call(native_function);
|
|
} else if Some(identifier) == self.chunk.name().map(|string| string.as_str()) {
|
|
let register = self.next_register();
|
|
|
|
self.emit_instruction(Instruction::load_self(register), start_position);
|
|
|
|
self.previous_expression_type = Type::SelfChunk;
|
|
|
|
return Ok(());
|
|
} else {
|
|
return Err(CompileError::UndeclaredVariable {
|
|
identifier: identifier.to_string(),
|
|
position: start_position,
|
|
});
|
|
};
|
|
|
|
let (is_mutable, local_scope) = {
|
|
let local = self.get_local(local_index)?;
|
|
|
|
(local.is_mutable, local.scope)
|
|
};
|
|
|
|
if !self.current_scope.contains(&local_scope) {
|
|
return Err(CompileError::VariableOutOfScope {
|
|
identifier: self.chunk.get_identifier(local_index).unwrap(),
|
|
position: start_position,
|
|
variable_scope: local_scope,
|
|
access_scope: self.current_scope,
|
|
});
|
|
}
|
|
|
|
if self.allow(Token::Equal)? {
|
|
if !is_mutable {
|
|
return Err(CompileError::CannotMutateImmutableVariable {
|
|
identifier: self.chunk.get_identifier(local_index).unwrap(),
|
|
position: start_position,
|
|
});
|
|
}
|
|
|
|
self.parse_expression()?;
|
|
|
|
let register = self.next_register() - 1;
|
|
|
|
self.emit_instruction(
|
|
Instruction::set_local(register, local_index),
|
|
start_position,
|
|
);
|
|
|
|
self.previous_expression_type = Type::None;
|
|
|
|
let mut optimizer = Optimizer::new(&mut self.chunk);
|
|
let optimized = optimizer.optimize_set_local();
|
|
|
|
if optimized {
|
|
self.optimization_count += 1;
|
|
}
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
let register = self.next_register();
|
|
|
|
self.emit_instruction(
|
|
Instruction::get_local(register, local_index),
|
|
self.previous_position,
|
|
);
|
|
|
|
let local = self.get_local(local_index)?;
|
|
|
|
self.previous_expression_type = local.r#type.clone();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_type_from(&mut self, token: Token, position: Span) -> Result<Type, CompileError> {
|
|
match token {
|
|
Token::Bool => Ok(Type::Boolean),
|
|
Token::FloatKeyword => Ok(Type::Float),
|
|
Token::Int => Ok(Type::Integer),
|
|
Token::Str => Ok(Type::String { length: None }),
|
|
_ => Err(CompileError::ExpectedTokenMultiple {
|
|
expected: &[
|
|
TokenKind::Bool,
|
|
TokenKind::FloatKeyword,
|
|
TokenKind::Int,
|
|
TokenKind::Str,
|
|
],
|
|
found: self.current_token.to_owned(),
|
|
position,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn parse_block(&mut self) -> Result<(), CompileError> {
|
|
self.advance()?;
|
|
|
|
self.block_index += 1;
|
|
|
|
self.current_scope.begin(self.block_index);
|
|
|
|
while !self.allow(Token::RightBrace)? && !self.is_eof() {
|
|
self.parse(Precedence::None)?;
|
|
}
|
|
|
|
self.current_scope.end();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_list(&mut self) -> Result<(), CompileError> {
|
|
let start = self.current_position.0;
|
|
|
|
self.advance()?;
|
|
|
|
let start_register = self.next_register();
|
|
let mut item_type = Type::Any;
|
|
|
|
while !self.allow(Token::RightBracket)? && !self.is_eof() {
|
|
let expected_register = self.next_register();
|
|
|
|
self.parse_expression()?;
|
|
|
|
if expected_register > start_register {
|
|
if let Err(conflict) = item_type.check(&self.previous_expression_type) {
|
|
return Err(CompileError::ListItemTypeConflict {
|
|
conflict,
|
|
position: self.previous_position,
|
|
});
|
|
}
|
|
}
|
|
|
|
item_type = self.previous_expression_type.clone();
|
|
let actual_register = self.next_register() - 1;
|
|
|
|
if expected_register < actual_register {
|
|
self.emit_instruction(
|
|
Instruction::close(expected_register, actual_register),
|
|
self.current_position,
|
|
);
|
|
}
|
|
|
|
self.allow(Token::Comma)?;
|
|
}
|
|
|
|
let to_register = self.next_register();
|
|
let end = self.current_position.1;
|
|
|
|
self.emit_instruction(
|
|
Instruction::load_list(to_register, start_register),
|
|
Span(start, end),
|
|
);
|
|
|
|
self.previous_expression_type = Type::List {
|
|
item_type: Box::new(item_type),
|
|
length: (to_register - start_register) as usize,
|
|
};
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_if(&mut self) -> Result<(), CompileError> {
|
|
self.advance()?;
|
|
self.parse_expression()?;
|
|
|
|
if matches!(
|
|
self.get_last_operations(),
|
|
Some([
|
|
Operation::Equal | Operation::Less | Operation::LessEqual,
|
|
Operation::Jump,
|
|
Operation::LoadBoolean,
|
|
Operation::LoadBoolean,
|
|
])
|
|
) {
|
|
self.chunk.instructions_mut().pop();
|
|
self.chunk.instructions_mut().pop();
|
|
self.chunk.instructions_mut().pop();
|
|
}
|
|
|
|
let if_block_start = self.chunk.len();
|
|
let if_block_start_position = self.current_position;
|
|
|
|
if let Token::LeftBrace = self.current_token {
|
|
self.parse_block()?;
|
|
} else {
|
|
return Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::LeftBrace,
|
|
found: self.current_token.to_owned(),
|
|
position: self.current_position,
|
|
});
|
|
}
|
|
|
|
let if_block_end = self.chunk.len();
|
|
let mut if_block_distance = (if_block_end - if_block_start) as u8;
|
|
let if_block_type = self.previous_expression_type.clone();
|
|
let if_last_register = self.next_register().saturating_sub(1);
|
|
|
|
if let Token::Else = self.current_token {
|
|
self.advance()?;
|
|
|
|
if let Token::LeftBrace = self.current_token {
|
|
self.parse_block()?;
|
|
} else {
|
|
return Err(CompileError::ExpectedTokenMultiple {
|
|
expected: &[TokenKind::If, TokenKind::LeftBrace],
|
|
found: self.current_token.to_owned(),
|
|
position: self.current_position,
|
|
});
|
|
}
|
|
|
|
true
|
|
} else if self.previous_expression_type != Type::None {
|
|
return Err(CompileError::IfMissingElse {
|
|
position: Span(if_block_start_position.0, self.current_position.1),
|
|
});
|
|
} else {
|
|
false
|
|
};
|
|
|
|
let else_block_end = self.chunk.len();
|
|
let else_block_distance = (else_block_end - if_block_end) as u8;
|
|
|
|
if let Err(conflict) = if_block_type.check(&self.previous_expression_type) {
|
|
return Err(CompileError::IfElseBranchMismatch {
|
|
conflict,
|
|
position: Span(if_block_start_position.0, self.current_position.1),
|
|
});
|
|
}
|
|
|
|
match else_block_distance {
|
|
0 => {}
|
|
1 => {
|
|
if let Some(skippable) =
|
|
self.get_last_jumpable_mut_between(1, if_block_distance as usize)
|
|
{
|
|
skippable.set_c_to_boolean(true);
|
|
} else {
|
|
if_block_distance += 1;
|
|
|
|
self.chunk.instructions_mut().insert(
|
|
if_block_end,
|
|
(
|
|
Instruction::jump(else_block_distance, true),
|
|
self.current_position,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
2.. => {
|
|
if_block_distance += 1;
|
|
|
|
self.chunk.instructions_mut().insert(
|
|
if_block_end,
|
|
(
|
|
Instruction::jump(else_block_distance, true),
|
|
self.current_position,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
self.chunk.instructions_mut().insert(
|
|
if_block_start,
|
|
(
|
|
Instruction::jump(if_block_distance, true),
|
|
if_block_start_position,
|
|
),
|
|
);
|
|
|
|
if self.chunk.len() >= 4 {
|
|
let mut optimizer = Optimizer::new(&mut self.chunk);
|
|
let optimized = optimizer.optimize_comparison();
|
|
|
|
if optimized {
|
|
self.optimization_count += 1
|
|
}
|
|
}
|
|
|
|
let else_last_register = self.next_register().saturating_sub(1);
|
|
|
|
if if_last_register < else_last_register {
|
|
self.emit_instruction(
|
|
Instruction::r#move(else_last_register, if_last_register),
|
|
self.current_position,
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_while(&mut self) -> Result<(), CompileError> {
|
|
self.advance()?;
|
|
|
|
let expression_start = self.chunk.len() as u8;
|
|
|
|
self.parse_expression()?;
|
|
|
|
if matches!(
|
|
self.get_last_operations(),
|
|
Some([
|
|
Operation::Equal | Operation::Less | Operation::LessEqual,
|
|
Operation::Jump,
|
|
Operation::LoadBoolean,
|
|
Operation::LoadBoolean,
|
|
],)
|
|
) {
|
|
self.chunk.instructions_mut().pop();
|
|
self.chunk.instructions_mut().pop();
|
|
self.chunk.instructions_mut().pop();
|
|
}
|
|
|
|
let block_start = self.chunk.len();
|
|
|
|
self.parse_block()?;
|
|
|
|
let block_end = self.chunk.len() as u8;
|
|
|
|
self.chunk.instructions_mut().insert(
|
|
block_start,
|
|
(
|
|
Instruction::jump(block_end - block_start as u8 + 1, true),
|
|
self.current_position,
|
|
),
|
|
);
|
|
|
|
let jump_back_distance = block_end - expression_start + 1;
|
|
let jump_back = Instruction::jump(jump_back_distance, false);
|
|
|
|
self.emit_instruction(jump_back, self.current_position);
|
|
|
|
self.previous_expression_type = Type::None;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_native_call(&mut self, function: NativeFunction) -> Result<(), CompileError> {
|
|
let start = self.previous_position.0;
|
|
let start_register = self.next_register();
|
|
|
|
self.expect(Token::LeftParenthesis)?;
|
|
|
|
while !self.allow(Token::RightParenthesis)? {
|
|
let expected_register = self.next_register();
|
|
|
|
self.parse_expression()?;
|
|
|
|
let actual_register = self.next_register() - 1;
|
|
|
|
if expected_register < actual_register {
|
|
self.emit_instruction(
|
|
Instruction::close(expected_register, actual_register),
|
|
self.current_position,
|
|
);
|
|
}
|
|
|
|
self.allow(Token::Comma)?;
|
|
}
|
|
|
|
let end = self.previous_position.1;
|
|
let to_register = self.next_register();
|
|
let argument_count = to_register - start_register;
|
|
|
|
self.previous_expression_type = *function.r#type().return_type;
|
|
|
|
self.emit_instruction(
|
|
Instruction::call_native(to_register, function, argument_count),
|
|
Span(start, end),
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_top_level(&mut self) -> Result<(), CompileError> {
|
|
loop {
|
|
self.parse(Precedence::None)?;
|
|
|
|
if self.is_eof() || self.allow(Token::RightBrace)? {
|
|
self.parse_implicit_return()?;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_expression(&mut self) -> Result<(), CompileError> {
|
|
self.parse(Precedence::None)?;
|
|
|
|
if self.previous_expression_type == Type::None || self.chunk.is_empty() {
|
|
return Err(CompileError::ExpectedExpression {
|
|
found: self.previous_token.to_owned(),
|
|
position: self.current_position,
|
|
});
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_sub_expression(&mut self, precedence: &Precedence) -> Result<(), CompileError> {
|
|
self.parse(precedence.increment())
|
|
}
|
|
|
|
fn parse_return_statement(&mut self) -> Result<(), CompileError> {
|
|
let start = self.current_position.0;
|
|
|
|
self.advance()?;
|
|
|
|
let has_return_value = if matches!(self.current_token, Token::Semicolon | Token::RightBrace)
|
|
{
|
|
self.update_return_type(Type::None)?;
|
|
|
|
false
|
|
} else {
|
|
self.parse_expression()?;
|
|
self.update_return_type(self.previous_expression_type.clone())?;
|
|
|
|
true
|
|
};
|
|
let end = self.current_position.1;
|
|
|
|
self.emit_instruction(Instruction::r#return(has_return_value), Span(start, end));
|
|
|
|
self.previous_expression_type = Type::None;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_implicit_return(&mut self) -> Result<(), CompileError> {
|
|
if self.allow(Token::Semicolon)? {
|
|
self.emit_instruction(Instruction::r#return(false), self.current_position);
|
|
} else {
|
|
self.emit_instruction(
|
|
Instruction::r#return(self.previous_expression_type != Type::None),
|
|
self.current_position,
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_let_statement(&mut self) -> Result<(), CompileError> {
|
|
self.advance()?;
|
|
|
|
let is_mutable = self.allow(Token::Mut)?;
|
|
let position = self.current_position;
|
|
let identifier = if let Token::Identifier(text) = self.current_token {
|
|
self.advance()?;
|
|
|
|
text
|
|
} else {
|
|
return Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::Identifier,
|
|
found: self.current_token.to_owned(),
|
|
position,
|
|
});
|
|
};
|
|
let explicit_type = if self.allow(Token::Colon)? {
|
|
self.advance()?;
|
|
|
|
let r#type = self.parse_type_from(self.current_token, self.current_position)?;
|
|
|
|
Some(r#type)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
self.expect(Token::Equal)?;
|
|
self.parse_expression()?;
|
|
|
|
let register = self.next_register() - 1;
|
|
let r#type = if let Some(r#type) = explicit_type {
|
|
r#type
|
|
} else {
|
|
self.get_register_type(register)?
|
|
};
|
|
let (local_index, _) =
|
|
self.declare_local(identifier, r#type, is_mutable, self.current_scope, register);
|
|
|
|
self.emit_instruction(
|
|
Instruction::define_local(register, local_index, is_mutable),
|
|
position,
|
|
);
|
|
|
|
self.previous_expression_type = Type::None;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_function(&mut self) -> Result<(), CompileError> {
|
|
let function_start = self.current_position.0;
|
|
let mut function_compiler = Compiler::new(self.lexer)?;
|
|
let identifier = if let Token::Identifier(text) = function_compiler.current_token {
|
|
let position = function_compiler.current_position;
|
|
|
|
function_compiler.advance()?;
|
|
function_compiler.chunk.set_name(text.to_string());
|
|
|
|
Some((text, position))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
function_compiler.expect(Token::LeftParenthesis)?;
|
|
|
|
let mut value_parameters: Option<Vec<(u8, Type)>> = None;
|
|
|
|
while function_compiler.current_token != Token::RightParenthesis {
|
|
let is_mutable = function_compiler.allow(Token::Mut)?;
|
|
let parameter = if let Token::Identifier(text) = function_compiler.current_token {
|
|
function_compiler.advance()?;
|
|
|
|
text
|
|
} else {
|
|
return Err(CompileError::ExpectedToken {
|
|
expected: TokenKind::Identifier,
|
|
found: function_compiler.current_token.to_owned(),
|
|
position: function_compiler.current_position,
|
|
});
|
|
};
|
|
|
|
function_compiler.expect(Token::Colon)?;
|
|
|
|
let r#type = function_compiler.parse_type_from(
|
|
function_compiler.current_token,
|
|
function_compiler.current_position,
|
|
)?;
|
|
|
|
function_compiler.advance()?;
|
|
|
|
let register = function_compiler.next_register();
|
|
let (_, identifier_index) = function_compiler.declare_local(
|
|
parameter,
|
|
r#type.clone(),
|
|
is_mutable,
|
|
function_compiler.current_scope,
|
|
register,
|
|
);
|
|
|
|
if let Some(value_parameters) = value_parameters.as_mut() {
|
|
value_parameters.push((identifier_index, r#type));
|
|
} else {
|
|
value_parameters = Some(vec![(identifier_index, r#type)]);
|
|
};
|
|
|
|
function_compiler.minimum_register += 1;
|
|
|
|
function_compiler.allow(Token::Comma)?;
|
|
}
|
|
|
|
function_compiler.advance()?;
|
|
|
|
let return_type = if function_compiler.allow(Token::ArrowThin)? {
|
|
let r#type = function_compiler.parse_type_from(
|
|
function_compiler.current_token,
|
|
function_compiler.current_position,
|
|
)?;
|
|
|
|
function_compiler.advance()?;
|
|
|
|
Box::new(r#type)
|
|
} else {
|
|
Box::new(Type::None)
|
|
};
|
|
let function_type = FunctionType {
|
|
type_parameters: None,
|
|
value_parameters,
|
|
return_type,
|
|
};
|
|
|
|
function_compiler.chunk.set_type(function_type.clone());
|
|
|
|
function_compiler.expect(Token::LeftBrace)?;
|
|
function_compiler.parse_top_level()?;
|
|
|
|
self.previous_token = function_compiler.previous_token;
|
|
self.previous_position = function_compiler.previous_position;
|
|
self.current_token = function_compiler.current_token;
|
|
self.current_position = function_compiler.current_position;
|
|
|
|
let function = ConcreteValue::Function(function_compiler.finish());
|
|
let constant_index = self.chunk.push_or_get_constant(function);
|
|
let function_end = self.current_position.1;
|
|
let register = self.next_register();
|
|
|
|
self.lexer.skip_to(function_end);
|
|
|
|
if let Some((identifier, identifier_position)) = identifier {
|
|
let (local_index, _) = self.declare_local(
|
|
identifier,
|
|
Type::Function(function_type),
|
|
false,
|
|
self.current_scope,
|
|
register,
|
|
);
|
|
|
|
self.emit_instruction(
|
|
Instruction::load_constant(register, constant_index, false),
|
|
Span(function_start, function_end),
|
|
);
|
|
self.emit_instruction(
|
|
Instruction::define_local(register, local_index, false),
|
|
identifier_position,
|
|
);
|
|
|
|
self.previous_expression_type = Type::None;
|
|
} else {
|
|
self.emit_instruction(
|
|
Instruction::load_constant(register, constant_index, false),
|
|
Span(function_start, function_end),
|
|
);
|
|
|
|
self.previous_expression_type = Type::Function(function_type);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_call(&mut self) -> Result<(), CompileError> {
|
|
let (last_instruction, _) =
|
|
self.chunk
|
|
.instructions()
|
|
.last()
|
|
.ok_or_else(|| CompileError::ExpectedExpression {
|
|
found: self.previous_token.to_owned(),
|
|
position: self.previous_position,
|
|
})?;
|
|
|
|
if !last_instruction.yields_value() {
|
|
return Err(CompileError::ExpectedExpression {
|
|
found: self.previous_token.to_owned(),
|
|
position: self.previous_position,
|
|
});
|
|
}
|
|
|
|
let function_register = last_instruction.a();
|
|
let register_type = self.get_register_type(function_register)?;
|
|
let function_return_type = match register_type {
|
|
Type::Function(function_type) => *function_type.return_type,
|
|
Type::SelfChunk => (*self.chunk.r#type().return_type).clone(),
|
|
_ => {
|
|
return Err(CompileError::ExpectedFunction {
|
|
found: self.previous_token.to_owned(),
|
|
actual_type: register_type,
|
|
position: self.previous_position,
|
|
});
|
|
}
|
|
};
|
|
let start = self.current_position.0;
|
|
|
|
self.advance()?;
|
|
|
|
while !self.allow(Token::RightParenthesis)? {
|
|
let expected_register = self.next_register();
|
|
|
|
self.parse_expression()?;
|
|
|
|
let actual_register = self.next_register() - 1;
|
|
|
|
if expected_register < actual_register {
|
|
self.emit_instruction(
|
|
Instruction::close(expected_register, actual_register),
|
|
self.current_position,
|
|
);
|
|
}
|
|
|
|
self.allow(Token::Comma)?;
|
|
}
|
|
|
|
let end = self.current_position.1;
|
|
let to_register = self.next_register();
|
|
let argument_count = to_register - function_register - 1;
|
|
|
|
self.emit_instruction(
|
|
Instruction::call(to_register, function_register, argument_count),
|
|
Span(start, end),
|
|
);
|
|
|
|
self.previous_expression_type = function_return_type;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_semicolon(&mut self) -> Result<(), CompileError> {
|
|
self.advance()?;
|
|
|
|
self.previous_expression_type = Type::None;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn expect_expression(&mut self) -> Result<(), CompileError> {
|
|
Err(CompileError::ExpectedExpression {
|
|
found: self.current_token.to_owned(),
|
|
position: self.current_position,
|
|
})
|
|
}
|
|
|
|
fn parse(&mut self, precedence: Precedence) -> Result<(), CompileError> {
|
|
if let Some(prefix_parser) = ParseRule::from(&self.current_token).prefix {
|
|
log::debug!(
|
|
"{} is prefix with precedence {precedence}",
|
|
self.current_token.to_string().bold(),
|
|
);
|
|
|
|
prefix_parser(self)?;
|
|
}
|
|
|
|
let mut infix_rule = ParseRule::from(&self.current_token);
|
|
|
|
while precedence <= infix_rule.precedence {
|
|
if let Some(infix_parser) = infix_rule.infix {
|
|
log::debug!(
|
|
"{} is infix with precedence {precedence}",
|
|
self.current_token.to_string().bold(),
|
|
);
|
|
|
|
if self.current_token == Token::Equal {
|
|
return Err(CompileError::InvalidAssignmentTarget {
|
|
found: self.current_token.to_owned(),
|
|
position: self.current_position,
|
|
});
|
|
}
|
|
|
|
infix_parser(self)?;
|
|
} else {
|
|
break;
|
|
}
|
|
|
|
infix_rule = ParseRule::from(&self.current_token);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Operator precedence levels.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub enum Precedence {
|
|
None,
|
|
Assignment,
|
|
Conditional,
|
|
LogicalOr,
|
|
LogicalAnd,
|
|
Equality,
|
|
Comparison,
|
|
Term,
|
|
Factor,
|
|
Unary,
|
|
Call,
|
|
Primary,
|
|
}
|
|
|
|
impl Precedence {
|
|
fn increment(&self) -> Self {
|
|
match self {
|
|
Precedence::None => Precedence::Assignment,
|
|
Precedence::Assignment => Precedence::Conditional,
|
|
Precedence::Conditional => Precedence::LogicalOr,
|
|
Precedence::LogicalOr => Precedence::LogicalAnd,
|
|
Precedence::LogicalAnd => Precedence::Equality,
|
|
Precedence::Equality => Precedence::Comparison,
|
|
Precedence::Comparison => Precedence::Term,
|
|
Precedence::Term => Precedence::Factor,
|
|
Precedence::Factor => Precedence::Unary,
|
|
Precedence::Unary => Precedence::Call,
|
|
Precedence::Call => Precedence::Primary,
|
|
Precedence::Primary => Precedence::Primary,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for Precedence {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
write!(f, "{:?}", self)
|
|
}
|
|
}
|
|
|
|
type Parser<'a> = fn(&mut Compiler<'a>) -> Result<(), CompileError>;
|
|
|
|
/// Rule that defines how to parse a token.
|
|
#[derive(Debug, Clone, Copy)]
|
|
struct ParseRule<'a> {
|
|
pub prefix: Option<Parser<'a>>,
|
|
pub infix: Option<Parser<'a>>,
|
|
pub precedence: Precedence,
|
|
}
|
|
|
|
impl From<&Token<'_>> for ParseRule<'_> {
|
|
fn from(token: &Token) -> Self {
|
|
match token {
|
|
Token::ArrowThin => ParseRule {
|
|
prefix: Some(Compiler::expect_expression),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Async => todo!(),
|
|
Token::Bang => ParseRule {
|
|
prefix: Some(Compiler::parse_unary),
|
|
infix: None,
|
|
precedence: Precedence::Unary,
|
|
},
|
|
Token::BangEqual => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_comparison_binary),
|
|
precedence: Precedence::Equality,
|
|
},
|
|
Token::Bool => ParseRule {
|
|
prefix: Some(Compiler::expect_expression),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Boolean(_) => ParseRule {
|
|
prefix: Some(Compiler::parse_boolean),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Break => todo!(),
|
|
Token::Byte(_) => ParseRule {
|
|
prefix: Some(Compiler::parse_byte),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Character(_) => ParseRule {
|
|
prefix: Some(Compiler::parse_character),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Colon => ParseRule {
|
|
prefix: Some(Compiler::expect_expression),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Comma => ParseRule {
|
|
prefix: None,
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Dot => ParseRule {
|
|
prefix: Some(Compiler::expect_expression),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::DoubleAmpersand => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_logical_binary),
|
|
precedence: Precedence::LogicalAnd,
|
|
},
|
|
Token::DoubleEqual => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_comparison_binary),
|
|
precedence: Precedence::Equality,
|
|
},
|
|
Token::DoublePipe => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_logical_binary),
|
|
precedence: Precedence::LogicalOr,
|
|
},
|
|
Token::DoubleDot => ParseRule {
|
|
prefix: Some(Compiler::expect_expression),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Eof => ParseRule {
|
|
prefix: None,
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Equal => ParseRule {
|
|
prefix: None,
|
|
infix: None,
|
|
precedence: Precedence::Assignment,
|
|
},
|
|
Token::Else => ParseRule {
|
|
prefix: None,
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Float(_) => ParseRule {
|
|
prefix: Some(Compiler::parse_float),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::FloatKeyword => ParseRule {
|
|
prefix: Some(Compiler::expect_expression),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Fn => ParseRule {
|
|
prefix: Some(Compiler::parse_function),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Greater => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_comparison_binary),
|
|
precedence: Precedence::Comparison,
|
|
},
|
|
Token::GreaterEqual => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_comparison_binary),
|
|
precedence: Precedence::Comparison,
|
|
},
|
|
Token::Identifier(_) => ParseRule {
|
|
prefix: Some(Compiler::parse_variable),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::If => ParseRule {
|
|
prefix: Some(Compiler::parse_if),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Int => ParseRule {
|
|
prefix: Some(Compiler::expect_expression),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Integer(_) => ParseRule {
|
|
prefix: Some(Compiler::parse_integer),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::LeftBrace => ParseRule {
|
|
prefix: Some(Compiler::parse_block),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::LeftParenthesis => ParseRule {
|
|
prefix: Some(Compiler::parse_grouped),
|
|
infix: Some(Compiler::parse_call),
|
|
precedence: Precedence::Call,
|
|
},
|
|
Token::LeftBracket => ParseRule {
|
|
prefix: Some(Compiler::parse_list),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Less => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_comparison_binary),
|
|
precedence: Precedence::Comparison,
|
|
},
|
|
Token::LessEqual => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_comparison_binary),
|
|
precedence: Precedence::Comparison,
|
|
},
|
|
Token::Let => ParseRule {
|
|
prefix: Some(Compiler::parse_let_statement),
|
|
infix: None,
|
|
precedence: Precedence::Assignment,
|
|
},
|
|
Token::Loop => todo!(),
|
|
Token::Map => todo!(),
|
|
Token::Minus => ParseRule {
|
|
prefix: Some(Compiler::parse_unary),
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Term,
|
|
},
|
|
Token::MinusEqual => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Assignment,
|
|
},
|
|
Token::Mut => ParseRule {
|
|
prefix: None,
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Percent => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Factor,
|
|
},
|
|
Token::PercentEqual => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Assignment,
|
|
},
|
|
Token::Plus => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Term,
|
|
},
|
|
Token::PlusEqual => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Assignment,
|
|
},
|
|
Token::Return => ParseRule {
|
|
prefix: Some(Compiler::parse_return_statement),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::RightBrace => ParseRule {
|
|
prefix: None,
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::RightParenthesis => ParseRule {
|
|
prefix: None,
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::RightBracket => ParseRule {
|
|
prefix: None,
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Semicolon => ParseRule {
|
|
prefix: Some(Compiler::parse_semicolon),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Slash => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Factor,
|
|
},
|
|
Token::SlashEqual => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Assignment,
|
|
},
|
|
Token::Star => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Factor,
|
|
},
|
|
Token::StarEqual => ParseRule {
|
|
prefix: None,
|
|
infix: Some(Compiler::parse_math_binary),
|
|
precedence: Precedence::Assignment,
|
|
},
|
|
Token::Str => ParseRule {
|
|
prefix: Some(Compiler::expect_expression),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::String(_) => ParseRule {
|
|
prefix: Some(Compiler::parse_string),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
Token::Struct => todo!(),
|
|
Token::While => ParseRule {
|
|
prefix: Some(Compiler::parse_while),
|
|
infix: None,
|
|
precedence: Precedence::None,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Compilation errors
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum CompileError {
|
|
// Token errors
|
|
ExpectedToken {
|
|
expected: TokenKind,
|
|
found: TokenOwned,
|
|
position: Span,
|
|
},
|
|
ExpectedTokenMultiple {
|
|
expected: &'static [TokenKind],
|
|
found: TokenOwned,
|
|
position: Span,
|
|
},
|
|
|
|
// Parsing errors
|
|
CannotChainComparison {
|
|
position: Span,
|
|
},
|
|
ExpectedExpression {
|
|
found: TokenOwned,
|
|
position: Span,
|
|
},
|
|
ExpectedFunction {
|
|
found: TokenOwned,
|
|
actual_type: Type,
|
|
position: Span,
|
|
},
|
|
ExpectedFunctionType {
|
|
found: Type,
|
|
position: Span,
|
|
},
|
|
InvalidAssignmentTarget {
|
|
found: TokenOwned,
|
|
position: Span,
|
|
},
|
|
UnexpectedReturn {
|
|
position: Span,
|
|
},
|
|
|
|
// Variable errors
|
|
CannotMutateImmutableVariable {
|
|
identifier: String,
|
|
position: Span,
|
|
},
|
|
ExpectedMutableVariable {
|
|
found: TokenOwned,
|
|
position: Span,
|
|
},
|
|
UndeclaredVariable {
|
|
identifier: String,
|
|
position: Span,
|
|
},
|
|
VariableOutOfScope {
|
|
identifier: String,
|
|
variable_scope: Scope,
|
|
access_scope: Scope,
|
|
position: Span,
|
|
},
|
|
|
|
// Type errors
|
|
CannotResolveRegisterType {
|
|
register_index: usize,
|
|
position: Span,
|
|
},
|
|
CannotResolveVariableType {
|
|
identifier: String,
|
|
position: Span,
|
|
},
|
|
IfElseBranchMismatch {
|
|
conflict: TypeConflict,
|
|
position: Span,
|
|
},
|
|
IfMissingElse {
|
|
position: Span,
|
|
},
|
|
ListItemTypeConflict {
|
|
conflict: TypeConflict,
|
|
position: Span,
|
|
},
|
|
ReturnTypeConflict {
|
|
conflict: TypeConflict,
|
|
position: Span,
|
|
},
|
|
|
|
// Wrappers around foreign errors
|
|
Chunk {
|
|
error: ChunkError,
|
|
position: Span,
|
|
},
|
|
Lex(LexError),
|
|
ParseFloatError {
|
|
error: ParseFloatError,
|
|
position: Span,
|
|
},
|
|
ParseIntError {
|
|
error: ParseIntError,
|
|
position: Span,
|
|
},
|
|
}
|
|
|
|
impl AnnotatedError for CompileError {
|
|
fn title() -> &'static str {
|
|
"Compilation Error"
|
|
}
|
|
|
|
fn description(&self) -> &'static str {
|
|
match self {
|
|
Self::CannotChainComparison { .. } => "Cannot chain comparison operations",
|
|
Self::CannotMutateImmutableVariable { .. } => "Cannot mutate immutable variable",
|
|
Self::CannotResolveRegisterType { .. } => "Cannot resolve register type",
|
|
Self::CannotResolveVariableType { .. } => "Cannot resolve type",
|
|
Self::Chunk { .. } => "Chunk error",
|
|
Self::ExpectedExpression { .. } => "Expected an expression",
|
|
Self::ExpectedFunction { .. } => "Expected a function",
|
|
Self::ExpectedFunctionType { .. } => "Expected a function type",
|
|
Self::ExpectedMutableVariable { .. } => "Expected a mutable variable",
|
|
Self::ExpectedToken { .. } => "Expected a specific token",
|
|
Self::ExpectedTokenMultiple { .. } => "Expected one of multiple tokens",
|
|
Self::IfElseBranchMismatch { .. } => "Type mismatch in if/else branches",
|
|
Self::IfMissingElse { .. } => "If statement missing else branch",
|
|
Self::InvalidAssignmentTarget { .. } => "Invalid assignment target",
|
|
Self::Lex(error) => error.description(),
|
|
Self::ListItemTypeConflict { .. } => "List item type conflict",
|
|
Self::ParseFloatError { .. } => "Failed to parse float",
|
|
Self::ParseIntError { .. } => "Failed to parse integer",
|
|
Self::ReturnTypeConflict { .. } => "Return type conflict",
|
|
Self::UndeclaredVariable { .. } => "Undeclared variable",
|
|
Self::UnexpectedReturn { .. } => "Unexpected return",
|
|
Self::VariableOutOfScope { .. } => "Variable out of scope",
|
|
}
|
|
}
|
|
|
|
fn details(&self) -> Option<String> {
|
|
match self {
|
|
Self::CannotMutateImmutableVariable { identifier, .. } => {
|
|
Some(format!("{identifier} is immutable"))
|
|
}
|
|
Self::Chunk { error, .. } => Some(error.to_string()),
|
|
Self::ExpectedExpression { found, .. } => Some(format!("Found {found}")),
|
|
Self::ExpectedFunction { found, actual_type, .. } => {
|
|
Some(format!("Expected \"{found}\" to be a function but it has type {actual_type}"))
|
|
}
|
|
Self::ExpectedFunctionType { found, .. } => {
|
|
Some(format!("Expected a function type but found {found}"))
|
|
}
|
|
Self::ExpectedToken {
|
|
expected, found, ..
|
|
} => Some(format!("Expected {expected} but found {found}")),
|
|
Self::ExpectedTokenMultiple {
|
|
expected, found, ..
|
|
} => {
|
|
let mut details = String::from("Expected");
|
|
|
|
for (index, token) in expected.iter().enumerate() {
|
|
details.push_str(&format!(" {token}"));
|
|
|
|
if index < expected.len() - 2 {
|
|
details.push_str(", ");
|
|
}
|
|
|
|
if index == expected.len() - 2 {
|
|
details.push_str(" or");
|
|
}
|
|
}
|
|
|
|
details.push_str(&format!(" but found {found}"));
|
|
|
|
Some(details)
|
|
}
|
|
Self::ExpectedMutableVariable { found, .. } => Some(format!("Found {found}")),
|
|
Self::IfElseBranchMismatch {
|
|
conflict: TypeConflict { expected, actual },
|
|
..
|
|
} => Some(
|
|
format!("This if block evaluates to type \"{expected}\" but the else block evaluates to \"{actual}\"")
|
|
),
|
|
Self::IfMissingElse { .. } => Some(
|
|
"This \"if\" expression evaluates to a value but is missing an else block"
|
|
.to_string(),
|
|
),
|
|
Self::InvalidAssignmentTarget { found, .. } => {
|
|
Some(format!("Cannot assign to {found}"))
|
|
}
|
|
Self::Lex(error) => error.details(),
|
|
Self::ParseFloatError { error, .. } => Some(error.to_string()),
|
|
Self::ParseIntError { error, .. } => Some(error.to_string()),
|
|
Self::ReturnTypeConflict {
|
|
conflict: TypeConflict { expected, actual },
|
|
..
|
|
} => Some(format!(
|
|
"Expected return type \"{expected}\" but found \"{actual}\""
|
|
)),
|
|
Self::UndeclaredVariable { identifier, .. } => {
|
|
Some(format!("{identifier} has not been declared"))
|
|
}
|
|
Self::UnexpectedReturn { .. } => None,
|
|
Self::VariableOutOfScope { identifier, .. } => {
|
|
Some(format!("{identifier} is out of scope"))
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn position(&self) -> Span {
|
|
match self {
|
|
Self::CannotChainComparison { position } => *position,
|
|
Self::CannotMutateImmutableVariable { position, .. } => *position,
|
|
Self::CannotResolveRegisterType { position, .. } => *position,
|
|
Self::CannotResolveVariableType { position, .. } => *position,
|
|
Self::Chunk { position, .. } => *position,
|
|
Self::ExpectedExpression { position, .. } => *position,
|
|
Self::ExpectedFunction { position, .. } => *position,
|
|
Self::ExpectedFunctionType { position, .. } => *position,
|
|
Self::ExpectedMutableVariable { position, .. } => *position,
|
|
Self::ExpectedToken { position, .. } => *position,
|
|
Self::ExpectedTokenMultiple { position, .. } => *position,
|
|
Self::IfElseBranchMismatch { position, .. } => *position,
|
|
Self::IfMissingElse { position } => *position,
|
|
Self::InvalidAssignmentTarget { position, .. } => *position,
|
|
Self::Lex(error) => error.position(),
|
|
Self::ListItemTypeConflict { position, .. } => *position,
|
|
Self::ParseFloatError { position, .. } => *position,
|
|
Self::ParseIntError { position, .. } => *position,
|
|
Self::ReturnTypeConflict { position, .. } => *position,
|
|
Self::UndeclaredVariable { position, .. } => *position,
|
|
Self::UnexpectedReturn { position } => *position,
|
|
Self::VariableOutOfScope { position, .. } => *position,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<LexError> for CompileError {
|
|
fn from(error: LexError) -> Self {
|
|
Self::Lex(error)
|
|
}
|
|
}
|