jeff/dust
1
0
Fork 0
Code Issues

Begin wrapping up overhaul

Browse Source
This commit is contained in:
Jeff 2024-11-16 01:29:21 -05:00
parent 7b91e879b7
commit 960931ce6e
17 changed files with 274 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
dust-lang/src/compiler.rs
View File

@ -418,7 +418,7 @@ impl<'src> Compiler<'src> {
let byte = u8::from_str_radix(&text[2..], 16) let byte = u8::from_str_radix(&text[2..], 16)
.map_err(|error| CompileError::ParseIntError { error, position })?; .map_err(|error| CompileError::ParseIntError { error, position })?;
let value = ConcreteValue::byte(byte); let value = ConcreteValue::Byte(byte);
self.emit_constant(value, position)?; self.emit_constant(value, position)?;
@ -440,7 +440,7 @@ impl<'src> Compiler<'src> {
if let Token::Character(character) = self.current_token { if let Token::Character(character) = self.current_token {
self.advance()?; self.advance()?;
let value = ConcreteValue::character(character); let value = ConcreteValue::Character(character);
self.emit_constant(value, position)?; self.emit_constant(value, position)?;
@ -468,7 +468,7 @@ impl<'src> Compiler<'src> {
error, error,
position: self.previous_position, position: self.previous_position,
})?; })?;
let value = ConcreteValue::float(float); let value = ConcreteValue::Float(float);
self.emit_constant(value, position)?; self.emit_constant(value, position)?;
@ -496,7 +496,7 @@ impl<'src> Compiler<'src> {
error, error,
position: self.previous_position, position: self.previous_position,
})?; })?;
let value = ConcreteValue::integer(integer); let value = ConcreteValue::Integer(integer);
self.emit_constant(value, position)?; self.emit_constant(value, position)?;
@ -1476,7 +1476,7 @@ impl<'src> Compiler<'src> {
value_parameters, value_parameters,
return_type, return_type,
}; };
let function = ConcreteValue::function(function_compiler.finish()); let function = ConcreteValue::Function(function_compiler.finish());
let constant_index = self.chunk.push_or_get_constant(function); let constant_index = self.chunk.push_or_get_constant(function);
let function_end = self.current_position.1; let function_end = self.current_position.1;
let register = self.next_register(); let register = self.next_register();

12
dust-lang/src/value/abstract_value.rs
View File

@ -1,14 +1,11 @@
use std::fmt::{self, Display, Formatter}; use std::fmt::{self, Display, Formatter};
use crate::{vm::Pointer, ConcreteValue, Type, Vm, VmError}; use crate::{vm::Pointer, ConcreteValue, Vm, VmError};
#[derive(Debug, PartialEq, PartialOrd)] #[derive(Debug, PartialEq, PartialOrd)]
pub enum AbstractValue { pub enum AbstractValue {
FunctionSelf, FunctionSelf,
List { List { items: Vec<Pointer> },
items: Vec<Pointer>,
item_type: Type,
},
} }
impl AbstractValue { impl AbstractValue {
@ -45,7 +42,7 @@ impl AbstractValue {
display.push_str(&item_display); display.push_str(&item_display);
} }
display.push_str("]"); display.push(']');
Ok(display) Ok(display)
} }
@ -59,9 +56,8 @@ impl Clone for AbstractValue {
match self { match self {
AbstractValue::FunctionSelf => AbstractValue::FunctionSelf, AbstractValue::FunctionSelf => AbstractValue::FunctionSelf,
AbstractValue::List { items, item_type } => AbstractValue::List { AbstractValue::List { items } => AbstractValue::List {
items: items.clone(), items: items.clone(),
item_type: item_type.clone(),
}, },
} }
} }

122
dust-lang/src/value/concrete_value.rs
View File

@ -20,38 +20,10 @@ pub enum ConcreteValue {
} }
impl ConcreteValue { impl ConcreteValue {
pub fn boolean(value: bool) -> Self {
ConcreteValue::Boolean(value)
}
pub fn byte(value: u8) -> Self {
ConcreteValue::Byte(value)
}
pub fn character(value: char) -> Self {
ConcreteValue::Character(value)
}
pub fn float(value: f64) -> Self {
ConcreteValue::Float(value)
}
pub fn function(chunk: Chunk) -> Self {
ConcreteValue::Function(chunk)
}
pub fn integer<T: Into<i64>>(into_i64: T) -> Self {
ConcreteValue::Integer(into_i64.into())
}
pub fn list<T: Into<Vec<ConcreteValue>>>(into_list: T) -> Self { pub fn list<T: Into<Vec<ConcreteValue>>>(into_list: T) -> Self {
ConcreteValue::List(into_list.into()) ConcreteValue::List(into_list.into())
} }
pub fn range(range: RangeValue) -> Self {
ConcreteValue::Range(range)
}
pub fn string<T: ToString>(to_string: T) -> Self { pub fn string<T: ToString>(to_string: T) -> Self {
ConcreteValue::String(to_string.to_string()) ConcreteValue::String(to_string.to_string())
} }
@ -91,9 +63,9 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let sum = match (self, other) { let sum = match (self, other) {
(Byte(left), Byte(right)) => ConcreteValue::byte(left.saturating_add(*right)), (Byte(left), Byte(right)) => ConcreteValue::Byte(left.saturating_add(*right)),
(Float(left), Float(right)) => ConcreteValue::float(*left + *right), (Float(left), Float(right)) => ConcreteValue::Float(*left + *right),
(Integer(left), Integer(right)) => ConcreteValue::integer(left.saturating_add(*right)), (Integer(left), Integer(right)) => ConcreteValue::Integer(left.saturating_add(*right)),
(String(left), String(right)) => ConcreteValue::string(format!("{}{}", left, right)), (String(left), String(right)) => ConcreteValue::string(format!("{}{}", left, right)),
_ => return Err(ValueError::CannotAdd(self.clone(), other.clone())), _ => return Err(ValueError::CannotAdd(self.clone(), other.clone())),
}; };
@ -105,9 +77,9 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let difference = match (self, other) { let difference = match (self, other) {
(Byte(left), Byte(right)) => ConcreteValue::byte(left.saturating_sub(*right)), (Byte(left), Byte(right)) => ConcreteValue::Byte(left.saturating_sub(*right)),
(Float(left), Float(right)) => ConcreteValue::float(left - right), (Float(left), Float(right)) => ConcreteValue::Float(left - right),
(Integer(left), Integer(right)) => ConcreteValue::integer(left.saturating_sub(*right)), (Integer(left), Integer(right)) => ConcreteValue::Integer(left.saturating_sub(*right)),
_ => return Err(ValueError::CannotSubtract(self.clone(), other.clone())), _ => return Err(ValueError::CannotSubtract(self.clone(), other.clone())),
}; };
@ -118,9 +90,9 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let product = match (self, other) { let product = match (self, other) {
(Byte(left), Byte(right)) => ConcreteValue::byte(left.saturating_mul(*right)), (Byte(left), Byte(right)) => ConcreteValue::Byte(left.saturating_mul(*right)),
(Float(left), Float(right)) => ConcreteValue::float(left * right), (Float(left), Float(right)) => ConcreteValue::Float(left * right),
(Integer(left), Integer(right)) => ConcreteValue::integer(left.saturating_mul(*right)), (Integer(left), Integer(right)) => ConcreteValue::Integer(left.saturating_mul(*right)),
_ => return Err(ValueError::CannotMultiply(self.clone(), other.clone())), _ => return Err(ValueError::CannotMultiply(self.clone(), other.clone())),
}; };
@ -131,9 +103,9 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let quotient = match (self, other) { let quotient = match (self, other) {
(Byte(left), Byte(right)) => ConcreteValue::byte(left.saturating_div(*right)), (Byte(left), Byte(right)) => ConcreteValue::Byte(left.saturating_div(*right)),
(Float(left), Float(right)) => ConcreteValue::float(left / right), (Float(left), Float(right)) => ConcreteValue::Float(left / right),
(Integer(left), Integer(right)) => ConcreteValue::integer(left.saturating_div(*right)), (Integer(left), Integer(right)) => ConcreteValue::Integer(left.saturating_div(*right)),
_ => return Err(ValueError::CannotMultiply(self.clone(), other.clone())), _ => return Err(ValueError::CannotMultiply(self.clone(), other.clone())),
}; };
@ -144,10 +116,10 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let product = match (self, other) { let product = match (self, other) {
(Byte(left), Byte(right)) => ConcreteValue::byte(left.wrapping_rem(*right)), (Byte(left), Byte(right)) => ConcreteValue::Byte(left.wrapping_rem(*right)),
(Float(left), Float(right)) => ConcreteValue::float(left % right), (Float(left), Float(right)) => ConcreteValue::Float(left % right),
(Integer(left), Integer(right)) => { (Integer(left), Integer(right)) => {
ConcreteValue::integer(left.wrapping_rem_euclid(*right)) ConcreteValue::Integer(left.wrapping_rem_euclid(*right))
} }
_ => return Err(ValueError::CannotMultiply(self.clone(), other.clone())), _ => return Err(ValueError::CannotMultiply(self.clone(), other.clone())),
}; };
@ -159,10 +131,10 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let negated = match self { let negated = match self {
Boolean(value) => ConcreteValue::boolean(!value), Boolean(value) => ConcreteValue::Boolean(!value),
Byte(value) => ConcreteValue::byte(value.wrapping_neg()), Byte(value) => ConcreteValue::Byte(value.wrapping_neg()),
Float(value) => ConcreteValue::float(-value), Float(value) => ConcreteValue::Float(-value),
Integer(value) => ConcreteValue::integer(value.wrapping_neg()), Integer(value) => ConcreteValue::Integer(value.wrapping_neg()),
_ => return Err(ValueError::CannotNegate(self.clone())), _ => return Err(ValueError::CannotNegate(self.clone())),
}; };
@ -173,7 +145,7 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let not = match self { let not = match self {
Boolean(value) => ConcreteValue::boolean(!value), Boolean(value) => ConcreteValue::Boolean(!value),
_ => return Err(ValueError::CannotNot(self.clone())), _ => return Err(ValueError::CannotNot(self.clone())),
}; };
@ -184,15 +156,15 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let equal = match (self, other) { let equal = match (self, other) {
(Boolean(left), Boolean(right)) => ConcreteValue::boolean(left == right), (Boolean(left), Boolean(right)) => ConcreteValue::Boolean(left == right),
(Byte(left), Byte(right)) => ConcreteValue::boolean(left == right), (Byte(left), Byte(right)) => ConcreteValue::Boolean(left == right),
(Character(left), Character(right)) => ConcreteValue::boolean(left == right), (Character(left), Character(right)) => ConcreteValue::Boolean(left == right),
(Float(left), Float(right)) => ConcreteValue::boolean(left == right), (Float(left), Float(right)) => ConcreteValue::Boolean(left == right),
(Function(left), Function(right)) => ConcreteValue::boolean(left == right), (Function(left), Function(right)) => ConcreteValue::Boolean(left == right),
(Integer(left), Integer(right)) => ConcreteValue::boolean(left == right), (Integer(left), Integer(right)) => ConcreteValue::Boolean(left == right),
(List(left), List(right)) => ConcreteValue::boolean(left == right), (List(left), List(right)) => ConcreteValue::Boolean(left == right),
(Range(left), Range(right)) => ConcreteValue::boolean(left == right), (Range(left), Range(right)) => ConcreteValue::Boolean(left == right),
(String(left), String(right)) => ConcreteValue::boolean(left == right), (String(left), String(right)) => ConcreteValue::Boolean(left == right),
_ => return Err(ValueError::CannotCompare(self.clone(), other.clone())), _ => return Err(ValueError::CannotCompare(self.clone(), other.clone())),
}; };
@ -203,15 +175,15 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let less_than = match (self, other) { let less_than = match (self, other) {
(Boolean(left), Boolean(right)) => ConcreteValue::boolean(left < right), (Boolean(left), Boolean(right)) => ConcreteValue::Boolean(left < right),
(Byte(left), Byte(right)) => ConcreteValue::boolean(left < right), (Byte(left), Byte(right)) => ConcreteValue::Boolean(left < right),
(Character(left), Character(right)) => ConcreteValue::boolean(left < right), (Character(left), Character(right)) => ConcreteValue::Boolean(left < right),
(Float(left), Float(right)) => ConcreteValue::boolean(left < right), (Float(left), Float(right)) => ConcreteValue::Boolean(left < right),
(Function(left), Function(right)) => ConcreteValue::boolean(left < right), (Function(left), Function(right)) => ConcreteValue::Boolean(left < right),
(Integer(left), Integer(right)) => ConcreteValue::boolean(left < right), (Integer(left), Integer(right)) => ConcreteValue::Boolean(left < right),
(List(left), List(right)) => ConcreteValue::boolean(left < right), (List(left), List(right)) => ConcreteValue::Boolean(left < right),
(Range(left), Range(right)) => ConcreteValue::boolean(left < right), (Range(left), Range(right)) => ConcreteValue::Boolean(left < right),
(String(left), String(right)) => ConcreteValue::boolean(left < right), (String(left), String(right)) => ConcreteValue::Boolean(left < right),
_ => return Err(ValueError::CannotCompare(self.clone(), other.clone())), _ => return Err(ValueError::CannotCompare(self.clone(), other.clone())),
}; };
@ -222,15 +194,15 @@ impl ConcreteValue {
use ConcreteValue::*; use ConcreteValue::*;
let less_than_or_equal = match (self, other) { let less_than_or_equal = match (self, other) {
(Boolean(left), Boolean(right)) => ConcreteValue::boolean(left <= right), (Boolean(left), Boolean(right)) => ConcreteValue::Boolean(left <= right),
(Byte(left), Byte(right)) => ConcreteValue::boolean(left <= right), (Byte(left), Byte(right)) => ConcreteValue::Boolean(left <= right),
(Character(left), Character(right)) => ConcreteValue::boolean(left <= right), (Character(left), Character(right)) => ConcreteValue::Boolean(left <= right),
(Float(left), Float(right)) => ConcreteValue::boolean(left <= right), (Float(left), Float(right)) => ConcreteValue::Boolean(left <= right),
(Function(left), Function(right)) => ConcreteValue::boolean(left <= right), (Function(left), Function(right)) => ConcreteValue::Boolean(left <= right),
(Integer(left), Integer(right)) => ConcreteValue::boolean(left <= right), (Integer(left), Integer(right)) => ConcreteValue::Boolean(left <= right),
(List(left), List(right)) => ConcreteValue::boolean(left <= right), (List(left), List(right)) => ConcreteValue::Boolean(left <= right),
(Range(left), Range(right)) => ConcreteValue::boolean(left <= right), (Range(left), Range(right)) => ConcreteValue::Boolean(left <= right),
(String(left), String(right)) => ConcreteValue::boolean(left <= right), (String(left), String(right)) => ConcreteValue::Boolean(left <= right),
_ => return Err(ValueError::CannotCompare(self.clone(), other.clone())), _ => return Err(ValueError::CannotCompare(self.clone(), other.clone())),
}; };

45
dust-lang/src/value/mod.rs
View File

@ -11,28 +11,7 @@ use std::fmt::{self, Debug, Display, Formatter};
use crate::{Vm, VmError}; use crate::{Vm, VmError};
#[derive(Clone, Debug)] #[derive(Clone, Debug, PartialEq, PartialOrd)]
pub enum ValueRef<'a> {
Abstract(&'a AbstractValue),
Concrete(&'a ConcreteValue),
}
impl ValueRef<'_> {
pub fn to_concrete_owned(&self, vm: &Vm) -> Result<ConcreteValue, VmError> {
match self {
ValueRef::Abstract(abstract_value) => abstract_value.to_concrete_owned(vm),
ValueRef::Concrete(concrete_value) => Ok((*concrete_value).clone()),
}
}
pub fn display(&self, vm: &Vm) -> Result<String, VmError> {
match self {
ValueRef::Abstract(abstract_value) => abstract_value.display(vm),
ValueRef::Concrete(concrete_value) => Ok(concrete_value.to_string()),
}
}
}
pub enum ValueOwned { pub enum ValueOwned {
Abstract(AbstractValue), Abstract(AbstractValue),
Concrete(ConcreteValue), Concrete(ConcreteValue),
@ -54,6 +33,28 @@ impl ValueOwned {
} }
} }
#[derive(Clone, Debug, PartialEq, PartialOrd)]
pub enum ValueRef<'a> {
Abstract(&'a AbstractValue),
Concrete(&'a ConcreteValue),
}
impl ValueRef<'_> {
pub fn to_concrete_owned(&self, vm: &Vm) -> Result<ConcreteValue, VmError> {
match self {
ValueRef::Abstract(abstract_value) => abstract_value.to_concrete_owned(vm),
ValueRef::Concrete(concrete_value) => Ok((*concrete_value).clone()),
}
}
pub fn display(&self, vm: &Vm) -> Result<String, VmError> {
match self {
ValueRef::Abstract(abstract_value) => abstract_value.display(vm),
ValueRef::Concrete(concrete_value) => Ok(concrete_value.to_string()),
}
}
}
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub enum ValueError { pub enum ValueError {
CannotAdd(ConcreteValue, ConcreteValue), CannotAdd(ConcreteValue, ConcreteValue),

100
dust-lang/src/vm.rs
View File

@ -14,19 +14,10 @@ use crate::{
pub fn run(source: &str) -> Result<Option<ConcreteValue>, DustError> { pub fn run(source: &str) -> Result<Option<ConcreteValue>, DustError> {
let chunk = compile(source)?; let chunk = compile(source)?;
let has_return_value = *chunk.r#type().return_type != Type::None;
let mut vm = Vm::new(&chunk, None); let mut vm = Vm::new(&chunk, None);
vm.run() vm.run()
.map_err(|error| DustError::Runtime { error, source })?; .map_err(|error| DustError::Runtime { error, source })
if has_return_value {
vm.take_top_of_stack_as_value()
.map(Some)
.map_err(|error| DustError::Runtime { error, source })
} else {
Ok(None)
}
} }
pub fn run_and_display_output(source: &str) { pub fn run_and_display_output(source: &str) {
@ -75,7 +66,7 @@ impl<'a> Vm<'a> {
self.current_position self.current_position
} }
pub fn run(&mut self) -> Result<Option<ValueRef>, VmError> { pub fn run(&mut self) -> Result<Option<ConcreteValue>, VmError> {
while let Ok(instruction) = self.read() { while let Ok(instruction) = self.read() {
log::info!( log::info!(
"{} | {} | {} | {}", "{} | {} | {} | {}",
@ -117,7 +108,7 @@ impl<'a> Vm<'a> {
let to_register = instruction.a(); let to_register = instruction.a();
let boolean = instruction.b_as_boolean(); let boolean = instruction.b_as_boolean();
let jump = instruction.c_as_boolean(); let jump = instruction.c_as_boolean();
let boolean = ConcreteValue::boolean(boolean); let boolean = ConcreteValue::Boolean(boolean);
self.set_register(to_register, Register::ConcreteValue(boolean))?; self.set_register(to_register, Register::ConcreteValue(boolean))?;
@ -142,24 +133,28 @@ impl<'a> Vm<'a> {
Operation::LoadList => { Operation::LoadList => {
let to_register = instruction.a(); let to_register = instruction.a();
let start_register = instruction.b(); let start_register = instruction.b();
let mut list = Vec::new(); let mut pointers = Vec::new();
for register_index in start_register..to_register { for register_index in start_register..to_register {
let value = self.open_register(register_index)?; if let Some(Register::Empty) = self.stack.get(register_index as usize) {
continue;
}
list.push(value); let pointer = Pointer::Stack(register_index);
pointers.push(pointer);
} }
// self.set_register(to_register, Register::List(list))?; self.set_register(
to_register,
todo!() Register::AbstractValue(AbstractValue::List { items: pointers }),
)?;
} }
Operation::LoadSelf => { Operation::LoadSelf => {
let to_register = instruction.a(); let to_register = instruction.a();
let register = Register::AbstractValue(AbstractValue::FunctionSelf);
// self.set_register(to_register, Register::Value(function))?; self.set_register(to_register, register)?;
todo!()
} }
Operation::DefineLocal => { Operation::DefineLocal => {
let from_register = instruction.a(); let from_register = instruction.a();
@ -263,13 +258,9 @@ impl<'a> Vm<'a> {
} }
Operation::TestSet => todo!(), Operation::TestSet => todo!(),
Operation::Equal => { Operation::Equal => {
debug_assert_eq!(
self.get_instruction(self.ip)?.0.operation(),
Operation::Jump
);
let compare_to = instruction.a_as_boolean(); let compare_to = instruction.a_as_boolean();
let (left, right) = self.get_arguments(instruction)?; let (left, right) = self.get_arguments(instruction)?;
let equal_result = left.equal(right).map_err(|error| VmError::Value { let equal_result = left.equal(right).map_err(|error| VmError::Value {
error, error,
position: self.current_position, position: self.current_position,
@ -286,17 +277,12 @@ impl<'a> Vm<'a> {
if is_equal == compare_to { if is_equal == compare_to {
self.ip += 1; self.ip += 1;
} else { } else {
let jump = self.get_instruction(self.ip)?.0; let jump = self.read()?;
self.jump(jump); self.jump(jump);
} }
} }
Operation::Less => { Operation::Less => {
debug_assert_eq!(
self.get_instruction(self.ip)?.0.operation(),
Operation::Jump
);
let compare_to = instruction.a_as_boolean(); let compare_to = instruction.a_as_boolean();
let (left, right) = self.get_arguments(instruction)?; let (left, right) = self.get_arguments(instruction)?;
let less_result = left.less_than(right).map_err(|error| VmError::Value { let less_result = left.less_than(right).map_err(|error| VmError::Value {
@ -315,17 +301,12 @@ impl<'a> Vm<'a> {
if is_less_than == compare_to { if is_less_than == compare_to {
self.ip += 1; self.ip += 1;
} else { } else {
let jump = self.get_instruction(self.ip)?.0; let jump = self.read()?;
self.jump(jump); self.jump(jump);
} }
} }
Operation::LessEqual => { Operation::LessEqual => {
debug_assert_eq!(
self.get_instruction(self.ip)?.0.operation(),
Operation::Jump
);
let compare_to = instruction.a_as_boolean(); let compare_to = instruction.a_as_boolean();
let (left, right) = self.get_arguments(instruction)?; let (left, right) = self.get_arguments(instruction)?;
let less_or_equal_result = let less_or_equal_result =
@ -347,7 +328,7 @@ impl<'a> Vm<'a> {
if is_less_than_or_equal == compare_to { if is_less_than_or_equal == compare_to {
self.ip += 1; self.ip += 1;
} else { } else {
let jump = self.get_instruction(self.ip)?.0; let jump = self.read()?;
self.jump(jump); self.jump(jump);
} }
@ -438,9 +419,11 @@ impl<'a> Vm<'a> {
} }
return if let Some(register_index) = self.last_assigned_register { return if let Some(register_index) = self.last_assigned_register {
let value_ref = self.open_register(register_index)?; let return_value = self
.open_register(register_index)?
.to_concrete_owned(self)?;
Ok(Some(value_ref)) Ok(Some(return_value))
} else { } else {
Err(VmError::StackUnderflow { Err(VmError::StackUnderflow {
position: self.current_position, position: self.current_position,
@ -508,20 +491,6 @@ impl<'a> Vm<'a> {
} }
} }
fn take_top_of_stack_as_value(&mut self) -> Result<ConcreteValue, VmError> {
let top_of_stack = self.stack.pop().ok_or(VmError::StackUnderflow {
position: self.current_position,
})?;
match top_of_stack {
Register::ConcreteValue(value) => Ok(value),
_ => Err(VmError::ExpectedValue {
found: top_of_stack,
position: self.current_position,
}),
}
}
/// DRY helper for handling JUMP instructions /// DRY helper for handling JUMP instructions
fn jump(&mut self, jump: Instruction) { fn jump(&mut self, jump: Instruction) {
let jump_distance = jump.b(); let jump_distance = jump.b();
@ -619,7 +588,14 @@ impl<'a> Vm<'a> {
} }
fn read(&mut self) -> Result<Instruction, VmError> { fn read(&mut self) -> Result<Instruction, VmError> {
let (instruction, position) = self.get_instruction(self.ip)?; let (instruction, position) =
self.chunk
.get_instruction(self.ip)
.copied()
.map_err(|error| VmError::Chunk {
error,
position: self.current_position,
})?;
self.ip += 1; self.ip += 1;
self.current_position = position; self.current_position = position;
@ -627,16 +603,6 @@ impl<'a> Vm<'a> {
Ok(instruction) Ok(instruction)
} }
fn get_instruction(&self, index: usize) -> Result<(Instruction, Span), VmError> {
self.chunk
.get_instruction(index)
.copied()
.map_err(|error| VmError::Chunk {
error,
position: self.current_position,
})
}
fn define_local(&mut self, local_index: u8, register_index: u8) -> Result<(), VmError> { fn define_local(&mut self, local_index: u8, register_index: u8) -> Result<(), VmError> {
log::debug!("Define local L{}", local_index); log::debug!("Define local L{}", local_index);
@ -650,8 +616,8 @@ impl<'a> Vm<'a> {
pub enum Register { pub enum Register {
Empty, Empty,
ConcreteValue(ConcreteValue), ConcreteValue(ConcreteValue),
Pointer(Pointer),
AbstractValue(AbstractValue), AbstractValue(AbstractValue),
Pointer(Pointer),
} }
impl Display for Register { impl Display for Register {

12
dust-lang/tests/basic.rs
View File

@ -12,12 +12,12 @@ fn constant() {
(Instruction::load_constant(0, 0, false), Span(0, 2)), (Instruction::load_constant(0, 0, false), Span(0, 2)),
(Instruction::r#return(true), Span(2, 2)) (Instruction::r#return(true), Span(2, 2))
], ],
vec![ValueOwned::Primitive(Primitive::Integer(42))], vec![ConcreteValue::Integer(42)],
vec![] vec![]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(42)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42))));
} }
#[test] #[test]
@ -58,13 +58,13 @@ fn parentheses_precedence() {
(Instruction::r#return(true), Span(11, 11)), (Instruction::r#return(true), Span(11, 11)),
], ],
vec![ vec![
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(3) ConcreteValue::Integer(3)
], ],
vec![] vec![]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(9)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(9))));
} }

24
dust-lang/tests/comparison.rs
View File

@ -20,12 +20,12 @@ fn equal() {
(Instruction::load_boolean(0, false, false), Span(2, 4)), (Instruction::load_boolean(0, false, false), Span(2, 4)),
(Instruction::r#return(true), Span(6, 6)), (Instruction::r#return(true), Span(6, 6)),
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(false)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false))));
} }
#[test] #[test]
@ -48,12 +48,12 @@ fn greater() {
(Instruction::load_boolean(0, false, false), Span(2, 3)), (Instruction::load_boolean(0, false, false), Span(2, 3)),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(false)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false))));
} }
#[test] #[test]
@ -76,12 +76,12 @@ fn greater_than_or_equal() {
(Instruction::load_boolean(0, false, false), Span(2, 4)), (Instruction::load_boolean(0, false, false), Span(2, 4)),
(Instruction::r#return(true), Span(6, 6)), (Instruction::r#return(true), Span(6, 6)),
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(false)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false))));
} }
#[test] #[test]
@ -104,12 +104,12 @@ fn less_than() {
(Instruction::load_boolean(0, false, false), Span(2, 3)), (Instruction::load_boolean(0, false, false), Span(2, 3)),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(true)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true))));
} }
#[test] #[test]
@ -132,12 +132,12 @@ fn less_than_or_equal() {
(Instruction::load_boolean(0, false, false), Span(2, 4)), (Instruction::load_boolean(0, false, false), Span(2, 4)),
(Instruction::r#return(true), Span(6, 6)), (Instruction::r#return(true), Span(6, 6)),
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(true)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true))));
} }
#[test] #[test]
@ -160,10 +160,10 @@ fn not_equal() {
(Instruction::load_boolean(0, false, false), Span(2, 4)), (Instruction::load_boolean(0, false, false), Span(2, 4)),
(Instruction::r#return(true), Span(6, 6)), (Instruction::r#return(true), Span(6, 6)),
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(true)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true))));
} }

80
dust-lang/tests/control_flow.rs
View File

@ -22,12 +22,12 @@ fn equality_assignment_long() {
(Instruction::get_local(1, 0), Span(43, 44)), (Instruction::get_local(1, 0), Span(43, 44)),
(Instruction::r#return(true), Span(44, 44)), (Instruction::r#return(true), Span(44, 44)),
], ],
vec![ValueOwned::integer(4), ValueOwned::string("a")], vec![ConcreteValue::Integer(4), ConcreteValue::string("a")],
vec![Local::new(1, Type::Boolean, false, Scope::default(),)] vec![Local::new(1, Type::Boolean, false, Scope::default(),)]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(true)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true))));
} }
#[test] #[test]
@ -52,12 +52,12 @@ fn equality_assignment_short() {
(Instruction::get_local(1, 0), Span(15, 16)), (Instruction::get_local(1, 0), Span(15, 16)),
(Instruction::r#return(true), Span(16, 16)), (Instruction::r#return(true), Span(16, 16)),
], ],
vec![ValueOwned::integer(4), ValueOwned::string("a")], vec![ConcreteValue::Integer(4), ConcreteValue::string("a")],
vec![Local::new(1, Type::Boolean, false, Scope::default())] vec![Local::new(1, Type::Boolean, false, Scope::default())]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(true)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true))));
} }
#[test] #[test]
@ -104,18 +104,18 @@ fn if_else_assigment_false() {
(Instruction::r#return(true), Span(149, 149)), (Instruction::r#return(true), Span(149, 149)),
], ],
vec![ vec![
ValueOwned::integer(4), ConcreteValue::Integer(4),
ValueOwned::integer(3), ConcreteValue::Integer(3),
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(42), ConcreteValue::Integer(42),
ValueOwned::string("a") ConcreteValue::string("a")
], ],
vec![Local::new(5, Type::Integer, false, Scope::default())] vec![Local::new(5, Type::Integer, false, Scope::default())]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(42)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42))));
} }
#[test] #[test]
@ -162,18 +162,18 @@ fn if_else_assigment_true() {
(Instruction::r#return(true), Span(149, 149)), (Instruction::r#return(true), Span(149, 149)),
], ],
vec![ vec![
ValueOwned::integer(4), ConcreteValue::Integer(4),
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(3), ConcreteValue::Integer(3),
ValueOwned::integer(42), ConcreteValue::Integer(42),
ValueOwned::string("a") ConcreteValue::string("a")
], ],
vec![Local::new(5, Type::Integer, false, Scope::default())] vec![Local::new(5, Type::Integer, false, Scope::default())]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(42)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42))));
} }
#[test] #[test]
@ -210,10 +210,10 @@ fn if_else_complex() {
(Instruction::r#return(false), Span(95, 95)), (Instruction::r#return(false), Span(95, 95)),
], ],
vec![ vec![
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(3), ConcreteValue::Integer(3),
ValueOwned::integer(4), ConcreteValue::Integer(4),
], ],
vec![] vec![]
)) ))
@ -275,21 +275,21 @@ fn if_else_complex() {
// (Instruction::r#return(true), Span(146, 146)), // (Instruction::r#return(true), Span(146, 146)),
// ], // ],
// vec![ // vec![
// ValueOwned::integer(0), // ConcreteValue::integer(0),
// ValueOwned::integer(1), // ConcreteValue::integer(1),
// ValueOwned::integer(0), // ConcreteValue::integer(0),
// ValueOwned::integer(2), // ConcreteValue::integer(2),
// ValueOwned::integer(1), // ConcreteValue::integer(1),
// ValueOwned::integer(0), // ConcreteValue::integer(0),
// ValueOwned::integer(3), // ConcreteValue::integer(3),
// ValueOwned::integer(3), // ConcreteValue::integer(3),
// ValueOwned::integer(4) // ConcreteValue::integer(4)
// ], // ],
// vec![] // vec![]
// )) // ))
// ); // );
// assert_eq!(run(source), Ok(Some(ValueOwned::integer(4)))); // assert_eq!(run(source), Ok(Some(ConcreteValue::integer(4))));
// } // }
#[test] #[test]
@ -317,15 +317,15 @@ fn if_else_false() {
(Instruction::r#return(true), Span(33, 33)), (Instruction::r#return(true), Span(33, 33)),
], ],
vec![ vec![
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(42) ConcreteValue::Integer(42)
], ],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(42)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42))));
} }
#[test] #[test]
@ -352,12 +352,12 @@ fn if_else_true() {
(Instruction::r#move(1, 0), Span(33, 33)), (Instruction::r#move(1, 0), Span(33, 33)),
(Instruction::r#return(true), Span(33, 33)) (Instruction::r#return(true), Span(33, 33))
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(42)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(42)],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(42)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42))));
} }
#[test] #[test]
@ -382,7 +382,7 @@ fn if_false() {
), ),
(Instruction::r#return(false), Span(21, 21)) (Instruction::r#return(false), Span(21, 21))
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)), )),
); );
@ -412,7 +412,7 @@ fn if_true() {
), ),
(Instruction::r#return(false), Span(21, 21)) (Instruction::r#return(false), Span(21, 21))
], ],
vec![ValueOwned::integer(1)], vec![ConcreteValue::Integer(1)],
vec![] vec![]
)), )),
); );

22
dust-lang/tests/functions.rs
View File

@ -6,13 +6,13 @@ fn function() {
assert_eq!( assert_eq!(
run(source), run(source),
Ok(Some(ValueOwned::function(Chunk::with_data( Ok(Some(ConcreteValue::Function(Chunk::with_data(
None, None,
vec![ vec![
(Instruction::add(2, 0, 1), Span(30, 31)), (Instruction::add(2, 0, 1), Span(30, 31)),
(Instruction::r#return(true), Span(35, 35)), (Instruction::r#return(true), Span(35, 35)),
], ],
vec![ValueOwned::string("a"), ValueOwned::string("b"),], vec![ConcreteValue::string("a"), ConcreteValue::string("b"),],
vec![ vec![
Local::new(0, Type::Integer, false, Scope::default()), Local::new(0, Type::Integer, false, Scope::default()),
Local::new(1, Type::Integer, false, Scope::default()) Local::new(1, Type::Integer, false, Scope::default())
@ -37,26 +37,26 @@ fn function_call() {
(Instruction::r#return(true), Span(41, 41)), (Instruction::r#return(true), Span(41, 41)),
], ],
vec![ vec![
ValueOwned::function(Chunk::with_data( ConcreteValue::Function(Chunk::with_data(
None, None,
vec![ vec![
(Instruction::add(2, 0, 1), Span(30, 31)), (Instruction::add(2, 0, 1), Span(30, 31)),
(Instruction::r#return(true), Span(35, 36)), (Instruction::r#return(true), Span(35, 36)),
], ],
vec![ValueOwned::string("a"), ValueOwned::string("b"),], vec![ConcreteValue::string("a"), ConcreteValue::string("b"),],
vec![ vec![
Local::new(0, Type::Integer, false, Scope::default()), Local::new(0, Type::Integer, false, Scope::default()),
Local::new(1, Type::Integer, false, Scope::default()) Local::new(1, Type::Integer, false, Scope::default())
] ]
)), )),
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2) ConcreteValue::Integer(2)
], ],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(3)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(3))));
} }
#[test] #[test]
@ -73,14 +73,14 @@ fn function_declaration() {
(Instruction::r#return(false), Span(40, 40)) (Instruction::r#return(false), Span(40, 40))
], ],
vec![ vec![
ValueOwned::string("add"), ConcreteValue::string("add"),
ValueOwned::function(Chunk::with_data( ConcreteValue::Function(Chunk::with_data(
None, Some("add".to_string()),
vec![ vec![
(Instruction::add(2, 0, 1), Span(35, 36)), (Instruction::add(2, 0, 1), Span(35, 36)),
(Instruction::r#return(true), Span(40, 40)), (Instruction::r#return(true), Span(40, 40)),
], ],
vec![ValueOwned::string("a"), ValueOwned::string("b")], vec![ConcreteValue::string("a"), ConcreteValue::string("b")],
vec![ vec![
Local::new(0, Type::Integer, false, Scope::default()), Local::new(0, Type::Integer, false, Scope::default()),
Local::new(1, Type::Integer, false, Scope::default()) Local::new(1, Type::Integer, false, Scope::default())

47
dust-lang/tests/lists.rs
View File

@ -17,7 +17,7 @@ fn empty_list() {
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::list([])))); assert_eq!(run(source), Ok(Some(ConcreteValue::list([]))));
} }
#[test] #[test]
@ -36,9 +36,9 @@ fn list() {
(Instruction::r#return(true), Span(9, 9)), (Instruction::r#return(true), Span(9, 9)),
], ],
vec![ vec![
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(3) ConcreteValue::Integer(3)
], ],
vec![] vec![]
)), )),
@ -46,10 +46,10 @@ fn list() {
assert_eq!( assert_eq!(
run(source), run(source),
Ok(Some(ValueOwned::list([ Ok(Some(ConcreteValue::list([
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(3) ConcreteValue::Integer(3)
]))) ])))
); );
} }
@ -82,11 +82,11 @@ fn list_with_complex_expression() {
(Instruction::r#return(true), Span(18, 18)), (Instruction::r#return(true), Span(18, 18)),
], ],
vec![ vec![
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(3), ConcreteValue::Integer(3),
ValueOwned::integer(4), ConcreteValue::Integer(4),
ValueOwned::integer(5) ConcreteValue::Integer(5)
], ],
vec![] vec![]
)), )),
@ -94,9 +94,9 @@ fn list_with_complex_expression() {
assert_eq!( assert_eq!(
run(source), run(source),
Ok(Some(ValueOwned::list([ Ok(Some(ConcreteValue::list([
ValueOwned::integer(0), ConcreteValue::Integer(1),
ValueOwned::integer(4) ConcreteValue::Integer(-15)
]))) ])))
); );
} }
@ -122,10 +122,10 @@ fn list_with_simple_expression() {
(Instruction::r#return(true), Span(13, 13)), (Instruction::r#return(true), Span(13, 13)),
], ],
vec![ vec![
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(3), ConcreteValue::Integer(3),
ValueOwned::integer(4), ConcreteValue::Integer(4),
], ],
vec![] vec![]
)), )),
@ -133,9 +133,10 @@ fn list_with_simple_expression() {
assert_eq!( assert_eq!(
run(source), run(source),
Ok(Some(ValueOwned::list([ Ok(Some(ConcreteValue::list([
ValueOwned::integer(0), ConcreteValue::Integer(1),
ValueOwned::integer(3) ConcreteValue::Integer(5),
ConcreteValue::Integer(4),
]))) ])))
); );
} }

8
dust-lang/tests/logic.rs
View File

@ -20,7 +20,7 @@ fn and() {
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(false)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false))));
} }
#[test] #[test]
@ -43,7 +43,7 @@ fn or() {
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(true)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(true))));
} }
#[test] #[test]
@ -65,7 +65,7 @@ fn variable_and() {
(Instruction::get_local(3, 1), Span(34, 35)), (Instruction::get_local(3, 1), Span(34, 35)),
(Instruction::r#return(true), Span(35, 35)), (Instruction::r#return(true), Span(35, 35)),
], ],
vec![ValueOwned::string("a"), ValueOwned::string("b"),], vec![ConcreteValue::string("a"), ConcreteValue::string("b"),],
vec![ vec![
Local::new(0, Type::Boolean, false, Scope::default()), Local::new(0, Type::Boolean, false, Scope::default()),
Local::new(1, Type::Boolean, false, Scope::default()), Local::new(1, Type::Boolean, false, Scope::default()),
@ -73,5 +73,5 @@ fn variable_and() {
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(false)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false))));
} }

10
dust-lang/tests/loops.rs
View File

@ -22,14 +22,14 @@ fn r#while() {
(Instruction::r#return(true), Span(42, 42)), (Instruction::r#return(true), Span(42, 42)),
], ],
vec![ vec![
ValueOwned::integer(0), ConcreteValue::Integer(0),
ValueOwned::string("x"), ConcreteValue::string("x"),
ValueOwned::integer(5), ConcreteValue::Integer(5),
ValueOwned::integer(1), ConcreteValue::Integer(1),
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, Type::Integer, true, Scope::default())]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(5)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(5))));
} }

56
dust-lang/tests/math.rs
View File

@ -17,12 +17,12 @@ fn add() {
), ),
(Instruction::r#return(true), Span(5, 5)) (Instruction::r#return(true), Span(5, 5))
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(3)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(3))));
} }
#[test] #[test]
@ -41,15 +41,15 @@ fn add_assign() {
(Instruction::r#return(true), Span(24, 24)) (Instruction::r#return(true), Span(24, 24))
], ],
vec![ vec![
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::string("a"), ConcreteValue::string("a"),
ValueOwned::integer(2) ConcreteValue::Integer(2)
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, Type::Integer, true, Scope::default())]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(3)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(3))));
} }
#[test] #[test]
@ -101,12 +101,12 @@ fn divide() {
), ),
(Instruction::r#return(true), Span(5, 5)) (Instruction::r#return(true), Span(5, 5))
], ],
vec![ValueOwned::integer(2)], vec![ConcreteValue::Integer(2)],
vec![] vec![]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(1)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(1))));
} }
#[test] #[test]
@ -127,12 +127,12 @@ fn divide_assign() {
(Instruction::get_local(1, 0), Span(23, 24)), (Instruction::get_local(1, 0), Span(23, 24)),
(Instruction::r#return(true), Span(24, 24)) (Instruction::r#return(true), Span(24, 24))
], ],
vec![ValueOwned::integer(2), ValueOwned::string("a")], vec![ConcreteValue::Integer(2), ConcreteValue::string("a")],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, Type::Integer, true, Scope::default())]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(1)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(1))));
} }
#[test] #[test]
@ -180,17 +180,17 @@ fn math_operator_precedence() {
(Instruction::r#return(true), Span(17, 17)), (Instruction::r#return(true), Span(17, 17)),
], ],
vec![ vec![
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::integer(3), ConcreteValue::Integer(3),
ValueOwned::integer(4), ConcreteValue::Integer(4),
ValueOwned::integer(5), ConcreteValue::Integer(5),
], ],
vec![] vec![]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(1)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(1))));
} }
#[test] #[test]
@ -210,12 +210,12 @@ fn multiply() {
), ),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(2)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(2))));
} }
#[test] #[test]
@ -237,15 +237,15 @@ fn multiply_assign() {
(Instruction::r#return(true), Span(23, 23)) (Instruction::r#return(true), Span(23, 23))
], ],
vec![ vec![
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::string("a"), ConcreteValue::string("a"),
ValueOwned::integer(3) ConcreteValue::Integer(3)
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, Type::Integer, true, Scope::default())]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(6)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(6))));
} }
#[test] #[test]
@ -281,12 +281,12 @@ fn subtract() {
), ),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
], ],
vec![ValueOwned::integer(1), ValueOwned::integer(2)], vec![ConcreteValue::Integer(1), ConcreteValue::Integer(2)],
vec![] vec![]
)) ))
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(-1)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(-1))));
} }
#[test] #[test]
@ -308,15 +308,15 @@ fn subtract_assign() {
(Instruction::r#return(true), Span(25, 25)), (Instruction::r#return(true), Span(25, 25)),
], ],
vec![ vec![
ValueOwned::integer(42), ConcreteValue::Integer(42),
ValueOwned::string("x"), ConcreteValue::string("x"),
ValueOwned::integer(2) ConcreteValue::Integer(2)
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, Type::Integer, true, Scope::default())]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(40)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(40))));
} }
#[test] #[test]

8
dust-lang/tests/native_functions.rs
View File

@ -18,8 +18,8 @@ fn panic() {
(Instruction::r#return(true), Span(27, 27)) (Instruction::r#return(true), Span(27, 27))
], ],
vec![ vec![
ValueOwned::string("Goodbye world!"), ConcreteValue::string("Goodbye world!"),
ValueOwned::integer(42) ConcreteValue::Integer(42)
], ],
vec![] vec![]
)), )),
@ -53,10 +53,10 @@ fn to_string() {
), ),
(Instruction::r#return(true), Span(13, 13)) (Instruction::r#return(true), Span(13, 13))
], ],
vec![ValueOwned::integer(42)], vec![ConcreteValue::Integer(42)],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::string("42")))) assert_eq!(run(source), Ok(Some(ConcreteValue::string("42"))))
} }

40
dust-lang/tests/scopes.rs
View File

@ -9,7 +9,7 @@ fn allow_access_to_parent_scope() {
} }
"#; "#;
assert_eq!(run(source), Ok(Some(ValueOwned::integer(1)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(1))));
} }
#[test] #[test]
@ -44,15 +44,15 @@ fn block_scope() {
(Instruction::r#return(false), Span(165, 165)) (Instruction::r#return(false), Span(165, 165))
], ],
vec![ vec![
ValueOwned::integer(0), ConcreteValue::Integer(0),
ValueOwned::string("a"), ConcreteValue::string("a"),
ValueOwned::integer(42), ConcreteValue::Integer(42),
ValueOwned::string("b"), ConcreteValue::string("b"),
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::string("c"), ConcreteValue::string("c"),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::string("d"), ConcreteValue::string("d"),
ValueOwned::string("e"), ConcreteValue::string("e"),
], ],
vec![ vec![
Local::new(1, Type::Integer, false, Scope::new(0, 0)), Local::new(1, Type::Integer, false, Scope::new(0, 0)),
@ -115,16 +115,16 @@ fn multiple_block_scopes() {
(Instruction::r#return(false), Span(307, 307)) (Instruction::r#return(false), Span(307, 307))
], ],
vec![ vec![
ValueOwned::integer(0), ConcreteValue::Integer(0),
ValueOwned::string("a"), ConcreteValue::string("a"),
ValueOwned::integer(42), ConcreteValue::Integer(42),
ValueOwned::string("b"), ConcreteValue::string("b"),
ValueOwned::integer(1), ConcreteValue::Integer(1),
ValueOwned::string("c"), ConcreteValue::string("c"),
ValueOwned::integer(2), ConcreteValue::Integer(2),
ValueOwned::string("d"), ConcreteValue::string("d"),
ValueOwned::string("q"), ConcreteValue::string("q"),
ValueOwned::string("e"), ConcreteValue::string("e"),
], ],
vec![ vec![
Local::new(1, Type::Integer, false, Scope::new(0, 0)), Local::new(1, Type::Integer, false, Scope::new(0, 0)),

6
dust-lang/tests/unary_operations.rs
View File

@ -12,12 +12,12 @@ fn negate() {
(*Instruction::negate(0, 0).set_b_is_constant(), Span(0, 1)), (*Instruction::negate(0, 0).set_b_is_constant(), Span(0, 1)),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
], ],
vec![ValueOwned::integer(42)], vec![ConcreteValue::Integer(42)],
vec![] vec![]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(-42)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(-42))));
} }
#[test] #[test]
@ -38,5 +38,5 @@ fn not() {
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::boolean(false)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Boolean(false))));
} }

10
dust-lang/tests/variables.rs
View File

@ -13,7 +13,7 @@ fn define_local() {
(Instruction::define_local(0, 0, false), Span(4, 5)), (Instruction::define_local(0, 0, false), Span(4, 5)),
(Instruction::r#return(false), Span(11, 11)) (Instruction::r#return(false), Span(11, 11))
], ],
vec![ValueOwned::integer(42), ValueOwned::string("x")], vec![ConcreteValue::Integer(42), ConcreteValue::string("x")],
vec![Local::new(1, Type::Integer, false, Scope::default())] vec![Local::new(1, Type::Integer, false, Scope::default())]
)), )),
); );
@ -55,13 +55,13 @@ fn set_local() {
(Instruction::r#return(true), Span(25, 25)), (Instruction::r#return(true), Span(25, 25)),
], ],
vec![ vec![
ValueOwned::integer(41), ConcreteValue::Integer(41),
ValueOwned::string("x"), ConcreteValue::string("x"),
ValueOwned::integer(42) ConcreteValue::Integer(42)
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, Type::Integer, true, Scope::default())]
)), )),
); );
assert_eq!(run(source), Ok(Some(ValueOwned::integer(42)))); assert_eq!(run(source), Ok(Some(ConcreteValue::Integer(42))));
} }