jeff/dust
1
0
Fork 0
Code Issues

Get all tests and source compiling without warnings

Browse Source
This commit is contained in:
Jeff 2024-12-10 03:34:41 -05:00
parent 847f3fd0b7
commit 3aed724649
29 changed files with 385 additions and 921 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dust-lang/src/chunk/mod.rs
View File

@ -135,8 +135,8 @@ impl Debug for Chunk {
let string = String::from_utf8_lossy(&output); let string = String::from_utf8_lossy(&output);
if cfg!(test) { if cfg!(debug_assertions) {
f.write_char('\n')?; f.write_char('\n')?; // Improves readability in Cargo test output
} }
write!(f, "{string}") write!(f, "{string}")

16
dust-lang/src/native_function/assertion.rs
View File

@ -1,15 +1,15 @@
use std::panic::{self, Location, PanicHookInfo}; use std::panic;
use annotate_snippets::{Level, Renderer, Snippet}; use annotate_snippets::{Level, Renderer, Snippet};
use smallvec::SmallVec; use smallvec::SmallVec;
use crate::{NativeFunctionError, Value, ValueRef, Vm}; use crate::{DustString, NativeFunctionError, Value, ValueRef, Vm};
pub fn panic( pub fn panic(
vm: &Vm, vm: &Vm,
arguments: SmallVec<[ValueRef; 4]>, arguments: SmallVec<[ValueRef; 4]>,
) -> Result<Option<Value>, NativeFunctionError> { ) -> Result<Option<Value>, NativeFunctionError> {
let mut message = String::new(); let mut message: Option<DustString> = None;
for value_ref in arguments { for value_ref in arguments {
let string = match value_ref.display(vm) { let string = match value_ref.display(vm) {
@ -17,7 +17,10 @@ pub fn panic(
Err(error) => return Err(NativeFunctionError::Vm(Box::new(error))), Err(error) => return Err(NativeFunctionError::Vm(Box::new(error))),
}; };
message.push_str(&string); match message {
Some(ref mut message) => message.push_str(&string),
None => message = Some(string),
}
} }
let position = vm.current_position(); let position = vm.current_position();
@ -33,7 +36,10 @@ pub fn panic(
panic::set_hook(Box::new(move |_| { panic::set_hook(Box::new(move |_| {
println!("{}", report); println!("{}", report);
println!("Panic Message: {}", message);
if let Some(message) = &message {
println!("{}", message);
}
})); }));
panic!(); panic!();

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

@ -36,7 +36,7 @@ fn empty() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}, },
vec![(Instruction::r#return(false), Span(0, 0))], vec![(Instruction::r#return(false), Span(0, 0))],
vec![], vec![],
@ -57,23 +57,15 @@ fn parentheses_precedence() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer) return_type: Type::Integer
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(3, 4) Span(3, 4)
), ),
( (
Instruction::multiply( Instruction::multiply(1, Argument::Register(0), Argument::Constant(2)),
Destination::Register(1),
Argument::Register(0),
Argument::Constant(2)
),
Span(8, 9) Span(8, 9)
), ),
(Instruction::r#return(true), Span(11, 11)), (Instruction::r#return(true), Span(11, 11)),
@ -101,39 +93,23 @@ fn math_operator_precedence() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(2, 3) Span(2, 3)
), ),
( (
Instruction::multiply( Instruction::multiply(1, Argument::Constant(2), Argument::Constant(3)),
Destination::Register(1),
Argument::Constant(2),
Argument::Constant(3)
),
Span(10, 11) Span(10, 11)
), ),
( (
Instruction::divide( Instruction::divide(2, Argument::Register(1), Argument::Constant(4)),
Destination::Register(2),
Argument::Register(1),
Argument::Constant(4)
),
Span(14, 15) Span(14, 15)
), ),
( (
Instruction::subtract( Instruction::subtract(3, Argument::Register(0), Argument::Register(2)),
Destination::Register(3),
Argument::Register(0),
Argument::Register(2)
),
Span(6, 7) Span(6, 7)
), ),
(Instruction::r#return(true), Span(17, 17)), (Instruction::r#return(true), Span(17, 17)),

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

@ -11,20 +11,11 @@ fn equal() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean) return_type: Type::Boolean
}, },
vec![ vec![
( (
Instruction::equal(true, Argument::Constant(0), Argument::Constant(1)), Instruction::equal(0, true, Argument::Constant(0), Argument::Constant(1)),
Span(2, 4)
),
(Instruction::jump(1, true), Span(2, 4)),
(
Instruction::load_boolean(Destination::Register(0), true, true),
Span(2, 4)
),
(
Instruction::load_boolean(Destination::Register(0), false, false),
Span(2, 4) Span(2, 4)
), ),
(Instruction::r#return(true), Span(6, 6)), (Instruction::r#return(true), Span(6, 6)),
@ -48,20 +39,11 @@ fn greater() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean) return_type: Type::Boolean
}, },
vec![ vec![
( (
Instruction::less_equal(false, Argument::Constant(0), Argument::Constant(1)), Instruction::less_equal(0, false, Argument::Constant(0), Argument::Constant(1)),
Span(2, 3)
),
(Instruction::jump(1, true), Span(2, 3)),
(
Instruction::load_boolean(Destination::Register(0), true, true),
Span(2, 3)
),
(
Instruction::load_boolean(Destination::Register(0), false, false),
Span(2, 3) Span(2, 3)
), ),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
@ -85,20 +67,11 @@ fn greater_than_or_equal() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean) return_type: Type::Boolean
}, },
vec![ vec![
( (
Instruction::less(false, Argument::Constant(0), Argument::Constant(1)), Instruction::less(0, false, Argument::Constant(0), Argument::Constant(1)),
Span(2, 4)
),
(Instruction::jump(1, true), Span(2, 4)),
(
Instruction::load_boolean(Destination::Register(0), true, true),
Span(2, 4)
),
(
Instruction::load_boolean(Destination::Register(0), false, false),
Span(2, 4) Span(2, 4)
), ),
(Instruction::r#return(true), Span(6, 6)), (Instruction::r#return(true), Span(6, 6)),
@ -122,20 +95,11 @@ fn less_than() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean) return_type: Type::Boolean
}, },
vec![ vec![
( (
Instruction::less(true, Argument::Constant(0), Argument::Constant(1)), Instruction::less(0, true, Argument::Constant(0), Argument::Constant(1)),
Span(2, 3)
),
(Instruction::jump(1, true), Span(2, 3)),
(
Instruction::load_boolean(Destination::Register(0), true, true),
Span(2, 3)
),
(
Instruction::load_boolean(Destination::Register(0), false, false),
Span(2, 3) Span(2, 3)
), ),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
@ -159,20 +123,11 @@ fn less_than_or_equal() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean) return_type: Type::Boolean
}, },
vec![ vec![
( (
Instruction::less_equal(true, Argument::Constant(0), Argument::Constant(1)), Instruction::less_equal(0, true, Argument::Constant(0), Argument::Constant(1)),
Span(2, 4)
),
(Instruction::jump(1, true), Span(2, 4)),
(
Instruction::load_boolean(Destination::Register(0), true, true),
Span(2, 4)
),
(
Instruction::load_boolean(Destination::Register(0), false, false),
Span(2, 4) Span(2, 4)
), ),
(Instruction::r#return(true), Span(6, 6)), (Instruction::r#return(true), Span(6, 6)),
@ -196,20 +151,11 @@ fn not_equal() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean) return_type: Type::Boolean
}, },
vec![ vec![
( (
Instruction::equal(false, Argument::Constant(0), Argument::Constant(1)), Instruction::equal(0, false, Argument::Constant(0), Argument::Constant(1)),
Span(2, 4)
),
(Instruction::jump(1, true), Span(2, 4)),
(
Instruction::load_boolean(Destination::Register(0), true, true),
Span(2, 4)
),
(
Instruction::load_boolean(Destination::Register(0), false, false),
Span(2, 4) Span(2, 4)
), ),
(Instruction::r#return(true), Span(6, 6)), (Instruction::r#return(true), Span(6, 6)),

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

@ -1,4 +1,5 @@
use dust_lang::*; use dust_lang::*;
use smallvec::smallvec;
#[test] #[test]
fn function() { fn function() {
@ -11,27 +12,23 @@ fn function() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Function(FunctionType { return_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: Some(vec![(0, Type::Integer), (1, Type::Integer)]), value_parameters: Some(smallvec![(0, Type::Integer), (1, Type::Integer)]),
return_type: Box::new(Type::Integer), return_type: Type::Integer,
})) })
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(2, Argument::Register(0), Argument::Register(1)),
Destination::Register(2),
Argument::Local(0),
Argument::Local(1)
),
Span(30, 31) Span(30, 31)
), ),
(Instruction::r#return(true), Span(34, 35)), (Instruction::r#return(true), Span(34, 35)),
], ],
vec![ConcreteValue::string("a"), ConcreteValue::string("b"),], vec![ConcreteValue::string("a"), ConcreteValue::string("b"),],
vec![ vec![
Local::new(0, Type::Integer, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Integer, false, Scope::default()) Local::new(1, 1, false, Scope::default())
] ]
)))) ))))
); );
@ -48,25 +45,13 @@ fn function_call() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer) return_type: Type::Integer
}, },
vec![ vec![
( (Instruction::load_constant(0, 0, false), Span(0, 35)),
Instruction::load_constant(Destination::Register(0), 0, false), (Instruction::load_constant(1, 1, false), Span(36, 37)),
Span(0, 35) (Instruction::load_constant(2, 2, false), Span(39, 40)),
), (Instruction::call(3, Argument::Constant(0), 2), Span(35, 41)),
(
Instruction::load_constant(Destination::Register(1), 1, false),
Span(36, 37)
),
(
Instruction::load_constant(Destination::Register(2), 2, false),
Span(39, 40)
),
(
Instruction::call(Destination::Register(3), Argument::Constant(0), 2),
Span(35, 41)
),
(Instruction::r#return(true), Span(41, 41)), (Instruction::r#return(true), Span(41, 41)),
], ],
vec![ vec![
@ -74,24 +59,20 @@ fn function_call() {
None, None,
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: Some(vec![(0, Type::Integer), (1, Type::Integer)]), value_parameters: Some(smallvec![(0, Type::Integer), (1, Type::Integer)]),
return_type: Box::new(Type::Integer) return_type: Type::Integer
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(2, Argument::Register(0), Argument::Register(1)),
Destination::Register(2),
Argument::Local(0),
Argument::Local(1)
),
Span(30, 31) Span(30, 31)
), ),
(Instruction::r#return(true), Span(34, 35)), (Instruction::r#return(true), Span(34, 35)),
], ],
vec![ConcreteValue::string("a"), ConcreteValue::string("b"),], vec![ConcreteValue::string("a"), ConcreteValue::string("b"),],
vec![ vec![
Local::new(0, Type::Integer, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Integer, false, Scope::default()) Local::new(1, 1, false, Scope::default())
] ]
)), )),
ConcreteValue::Integer(1), ConcreteValue::Integer(1),
@ -115,14 +96,10 @@ fn function_declaration() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}, },
vec![ vec![
( (Instruction::load_constant(0, 0, false), Span(0, 40)),
Instruction::load_constant(Destination::Register(0), 0, false),
Span(0, 40)
),
(Instruction::define_local(0, 0, false), Span(3, 6)),
(Instruction::r#return(false), Span(40, 40)) (Instruction::r#return(false), Span(40, 40))
], ],
vec![ vec![
@ -130,38 +107,25 @@ fn function_declaration() {
Some("add".into()), Some("add".into()),
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: Some(vec![(0, Type::Integer), (1, Type::Integer)]), value_parameters: Some(smallvec![(0, Type::Integer), (1, Type::Integer)]),
return_type: Box::new(Type::Integer) return_type: Type::Integer
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(2, Argument::Register(0), Argument::Register(1)),
Destination::Register(2),
Argument::Local(0),
Argument::Local(1)
),
Span(35, 36) Span(35, 36)
), ),
(Instruction::r#return(true), Span(39, 40)), (Instruction::r#return(true), Span(39, 40)),
], ],
vec![ConcreteValue::string("a"), ConcreteValue::string("b")], vec![ConcreteValue::string("a"), ConcreteValue::string("b")],
vec![ vec![
Local::new(0, Type::Integer, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Integer, false, Scope::default()) Local::new(1, 1, false, Scope::default())
] ]
)), )),
ConcreteValue::string("add"), ConcreteValue::string("add"),
], ],
vec![Local::new( vec![Local::new(1, 0, false, Scope::default(),),],
1,
Type::Function(FunctionType {
type_parameters: None,
value_parameters: Some(vec![(0, Type::Integer), (1, Type::Integer)]),
return_type: Box::new(Type::Integer),
}),
false,
Scope::default(),
),],
)), )),
); );

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

@ -11,13 +11,10 @@ fn empty_list() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::List(Box::new(Type::Any))), return_type: Type::List(Box::new(Type::Any)),
}, },
vec![ vec![
( (Instruction::load_list(0, 0), Span(0, 2)),
Instruction::load_list(Destination::Register(0), 0),
Span(0, 2)
),
(Instruction::r#return(true), Span(2, 2)), (Instruction::r#return(true), Span(2, 2)),
], ],
vec![], vec![],
@ -39,25 +36,13 @@ fn list() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::List(Box::new(Type::Integer))), return_type: Type::List(Box::new(Type::Integer)),
}, },
vec![ vec![
( (Instruction::load_constant(0, 0, false), Span(1, 2)),
Instruction::load_constant(Destination::Register(0), 0, false), (Instruction::load_constant(1, 1, false), Span(4, 5)),
Span(1, 2) (Instruction::load_constant(2, 2, false), Span(7, 8)),
), (Instruction::load_list(3, 0), Span(0, 9)),
(
Instruction::load_constant(Destination::Register(1), 1, false),
Span(4, 5)
),
(
Instruction::load_constant(Destination::Register(2), 2, false),
Span(7, 8)
),
(
Instruction::load_list(Destination::Register(3), 0),
Span(0, 9)
),
(Instruction::r#return(true), Span(9, 9)), (Instruction::r#return(true), Span(9, 9)),
], ],
vec![ vec![
@ -90,42 +75,24 @@ fn list_with_complex_expression() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::List(Box::new(Type::Integer))), return_type: Type::List(Box::new(Type::Integer)),
}, },
vec![ vec![
(Instruction::load_constant(0, 0, false), Span(1, 2)),
( (
Instruction::load_constant(Destination::Register(0), 0, false), Instruction::add(1, Argument::Constant(1), Argument::Constant(2)),
Span(1, 2)
),
(
Instruction::add(
Destination::Register(1),
Argument::Constant(1),
Argument::Constant(2)
),
Span(6, 7) Span(6, 7)
), ),
( (
Instruction::multiply( Instruction::multiply(2, Argument::Constant(3), Argument::Constant(4)),
Destination::Register(2),
Argument::Constant(3),
Argument::Constant(4)
),
Span(14, 15) Span(14, 15)
), ),
( (
Instruction::subtract( Instruction::subtract(3, Argument::Register(1), Argument::Register(2)),
Destination::Register(3),
Argument::Register(1),
Argument::Register(2)
),
Span(10, 11) Span(10, 11)
), ),
(Instruction::close(1, 3), Span(17, 18)), (Instruction::close(1, 3), Span(17, 18)),
( (Instruction::load_list(4, 0), Span(0, 18)),
Instruction::load_list(Destination::Register(4), 0),
Span(0, 18)
),
(Instruction::r#return(true), Span(18, 18)), (Instruction::r#return(true), Span(18, 18)),
], ],
vec![ vec![
@ -159,29 +126,16 @@ fn list_with_simple_expression() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::List(Box::new(Type::Integer))), return_type: Type::List(Box::new(Type::Integer)),
}, },
vec![ vec![
(Instruction::load_constant(0, 0, false), Span(1, 2)),
( (
Instruction::load_constant(Destination::Register(0), 0, false), Instruction::add(1, Argument::Constant(1), Argument::Constant(2)),
Span(1, 2)
),
(
Instruction::add(
Destination::Register(1),
Argument::Constant(1),
Argument::Constant(2)
),
Span(6, 7) Span(6, 7)
), ),
( (Instruction::load_constant(2, 3, false), Span(11, 12)),
Instruction::load_constant(Destination::Register(2), 3, false), (Instruction::load_list(3, 0), Span(0, 13)),
Span(11, 12)
),
(
Instruction::load_list(Destination::Register(3), 0),
Span(0, 13)
),
(Instruction::r#return(true), Span(13, 13)), (Instruction::r#return(true), Span(13, 13)),
], ],
vec![ vec![

48
dust-lang/tests/logic_and.rs
View File

@ -11,19 +11,13 @@ fn true_and_true() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, true, false), Span(0, 4)),
Instruction::load_boolean(Destination::Register(0), true, false),
Span(0, 4)
),
(Instruction::test(Argument::Register(0), true), Span(5, 7)), (Instruction::test(Argument::Register(0), true), Span(5, 7)),
(Instruction::jump(1, true), Span(5, 7)), (Instruction::jump(1, true), Span(5, 7)),
( (Instruction::load_boolean(1, true, false), Span(8, 12)),
Instruction::load_boolean(Destination::Register(1), true, false),
Span(8, 12)
),
(Instruction::r#return(true), Span(12, 12)), (Instruction::r#return(true), Span(12, 12)),
], ],
vec![], vec![],
@ -45,19 +39,13 @@ fn false_and_false() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, false, false), Span(0, 5)),
Instruction::load_boolean(Destination::Register(0), false, false),
Span(0, 5)
),
(Instruction::test(Argument::Register(0), true), Span(6, 8)), (Instruction::test(Argument::Register(0), true), Span(6, 8)),
(Instruction::jump(1, true), Span(6, 8)), (Instruction::jump(1, true), Span(6, 8)),
( (Instruction::load_boolean(1, false, false), Span(9, 14)),
Instruction::load_boolean(Destination::Register(1), false, false),
Span(9, 14)
),
(Instruction::r#return(true), Span(14, 14)), (Instruction::r#return(true), Span(14, 14)),
], ],
vec![], vec![],
@ -79,19 +67,13 @@ fn false_and_true() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, false, false), Span(0, 5)),
Instruction::load_boolean(Destination::Register(0), false, false),
Span(0, 5)
),
(Instruction::test(Argument::Register(0), true), Span(6, 8)), (Instruction::test(Argument::Register(0), true), Span(6, 8)),
(Instruction::jump(1, true), Span(6, 8)), (Instruction::jump(1, true), Span(6, 8)),
( (Instruction::load_boolean(1, true, false), Span(9, 13)),
Instruction::load_boolean(Destination::Register(1), true, false),
Span(9, 13)
),
(Instruction::r#return(true), Span(13, 13)), (Instruction::r#return(true), Span(13, 13)),
], ],
vec![], vec![],
@ -113,19 +95,13 @@ fn true_and_false() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, true, false), Span(0, 4)),
Instruction::load_boolean(Destination::Register(0), true, false),
Span(0, 4)
),
(Instruction::test(Argument::Register(0), true), Span(5, 7)), (Instruction::test(Argument::Register(0), true), Span(5, 7)),
(Instruction::jump(1, true), Span(5, 7)), (Instruction::jump(1, true), Span(5, 7)),
( (Instruction::load_boolean(1, false, false), Span(8, 13)),
Instruction::load_boolean(Destination::Register(1), false, false),
Span(8, 13)
),
(Instruction::r#return(true), Span(13, 13)), (Instruction::r#return(true), Span(13, 13)),
], ],
vec![], vec![],

17
dust-lang/tests/logic_and_and.rs
View File

@ -11,25 +11,16 @@ fn true_and_true_and_true() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, true, false), Span(0, 4)),
Instruction::load_boolean(Destination::Register(0), true, false),
Span(0, 4)
),
(Instruction::test(Argument::Register(0), true), Span(5, 7)), (Instruction::test(Argument::Register(0), true), Span(5, 7)),
(Instruction::jump(1, true), Span(5, 7)), (Instruction::jump(1, true), Span(5, 7)),
( (Instruction::load_boolean(1, true, false), Span(8, 12)),
Instruction::load_boolean(Destination::Register(1), true, false),
Span(8, 12)
),
(Instruction::test(Argument::Register(1), true), Span(13, 15)), (Instruction::test(Argument::Register(1), true), Span(13, 15)),
(Instruction::jump(1, true), Span(13, 15)), (Instruction::jump(1, true), Span(13, 15)),
( (Instruction::load_boolean(2, true, false), Span(16, 20)),
Instruction::load_boolean(Destination::Register(2), true, false),
Span(16, 20)
),
(Instruction::r#return(true), Span(20, 20)), (Instruction::r#return(true), Span(20, 20)),
], ],
vec![], vec![],

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

@ -11,19 +11,13 @@ fn true_or_false() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, true, false), Span(0, 4)),
Instruction::load_boolean(Destination::Register(0), true, false),
Span(0, 4)
),
(Instruction::test(Argument::Register(0), false), Span(5, 7)), (Instruction::test(Argument::Register(0), false), Span(5, 7)),
(Instruction::jump(1, true), Span(5, 7)), (Instruction::jump(1, true), Span(5, 7)),
( (Instruction::load_boolean(1, false, false), Span(8, 13)),
Instruction::load_boolean(Destination::Register(1), false, false),
Span(8, 13)
),
(Instruction::r#return(true), Span(13, 13)), (Instruction::r#return(true), Span(13, 13)),
], ],
vec![], vec![],

254
dust-lang/tests/logic_variables.rs
View File

@ -11,35 +11,21 @@ fn true_and_true() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, true, false), Span(8, 12)),
Instruction::load_boolean(Destination::Register(0), true, false), (Instruction::load_boolean(1, true, false), Span(22, 26)),
Span(8, 12) (Instruction::get_local(2, 0), Span(28, 29)),
), (Instruction::test(Argument::Register(0), true), Span(30, 32)),
(Instruction::define_local(0, 0, false), Span(4, 5)),
(
Instruction::load_boolean(Destination::Register(1), true, false),
Span(22, 26)
),
(Instruction::define_local(1, 1, false), Span(18, 19)),
(
Instruction::get_local(Destination::Register(2), 0),
Span(28, 29)
),
(Instruction::test(Argument::Local(0), true), Span(30, 32)),
(Instruction::jump(1, true), Span(30, 32)), (Instruction::jump(1, true), Span(30, 32)),
( (Instruction::get_local(3, 1), Span(33, 34)),
Instruction::get_local(Destination::Register(3), 1),
Span(33, 34)
),
(Instruction::r#return(true), Span(34, 34)), (Instruction::r#return(true), Span(34, 34)),
], ],
vec![ConcreteValue::string("a"), ConcreteValue::string("b")], vec![ConcreteValue::string("a"), ConcreteValue::string("b")],
vec![ vec![
Local::new(0, Type::Boolean, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Boolean, false, Scope::default()) Local::new(1, 1, false, Scope::default())
] ]
)) ))
); );
@ -58,35 +44,21 @@ fn false_and_false() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, false, false), Span(8, 13)),
Instruction::load_boolean(Destination::Register(0), false, false), (Instruction::load_boolean(1, false, false), Span(23, 28)),
Span(8, 13) (Instruction::get_local(2, 0), Span(30, 31)),
), (Instruction::test(Argument::Register(0), true), Span(32, 34)),
(Instruction::define_local(0, 0, false), Span(4, 5)),
(
Instruction::load_boolean(Destination::Register(1), false, false),
Span(23, 28)
),
(Instruction::define_local(1, 1, false), Span(19, 20)),
(
Instruction::get_local(Destination::Register(2), 0),
Span(30, 31)
),
(Instruction::test(Argument::Local(0), true), Span(32, 34)),
(Instruction::jump(1, true), Span(32, 34)), (Instruction::jump(1, true), Span(32, 34)),
( (Instruction::get_local(3, 1), Span(35, 36)),
Instruction::get_local(Destination::Register(3), 1),
Span(35, 36)
),
(Instruction::r#return(true), Span(36, 36)), (Instruction::r#return(true), Span(36, 36)),
], ],
vec![ConcreteValue::string("a"), ConcreteValue::string("b")], vec![ConcreteValue::string("a"), ConcreteValue::string("b")],
vec![ vec![
Local::new(0, Type::Boolean, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Boolean, false, Scope::default()) Local::new(1, 0, false, Scope::default())
] ]
)) ))
); );
@ -105,35 +77,21 @@ fn true_and_false() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, true, false), Span(8, 12)),
Instruction::load_boolean(Destination::Register(0), true, false), (Instruction::load_boolean(1, false, false), Span(22, 27)),
Span(8, 12) (Instruction::get_local(2, 0), Span(29, 30)),
), (Instruction::test(Argument::Register(0), true), Span(31, 33)),
(Instruction::define_local(0, 0, false), Span(4, 5)),
(
Instruction::load_boolean(Destination::Register(1), false, false),
Span(22, 27)
),
(Instruction::define_local(1, 1, false), Span(18, 19)),
(
Instruction::get_local(Destination::Register(2), 0),
Span(29, 30)
),
(Instruction::test(Argument::Local(0), true), Span(31, 33)),
(Instruction::jump(1, true), Span(31, 33)), (Instruction::jump(1, true), Span(31, 33)),
( (Instruction::get_local(3, 1), Span(34, 35)),
Instruction::get_local(Destination::Register(3), 1),
Span(34, 35)
),
(Instruction::r#return(true), Span(35, 35)), (Instruction::r#return(true), Span(35, 35)),
], ],
vec![ConcreteValue::string("a"), ConcreteValue::string("b")], vec![ConcreteValue::string("a"), ConcreteValue::string("b")],
vec![ vec![
Local::new(0, Type::Boolean, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Boolean, false, Scope::default()) Local::new(1, 1, false, Scope::default())
] ]
)) ))
); );
@ -152,35 +110,21 @@ fn false_and_true() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, false, false), Span(8, 13)),
Instruction::load_boolean(Destination::Register(0), false, false), (Instruction::load_boolean(1, true, false), Span(23, 27)),
Span(8, 13) (Instruction::get_local(2, 0), Span(29, 30)),
), (Instruction::test(Argument::Register(0), true), Span(31, 33)),
(Instruction::define_local(0, 0, false), Span(4, 5)),
(
Instruction::load_boolean(Destination::Register(1), true, false),
Span(23, 27)
),
(Instruction::define_local(1, 1, false), Span(19, 20)),
(
Instruction::get_local(Destination::Register(2), 0),
Span(29, 30)
),
(Instruction::test(Argument::Local(0), true), Span(31, 33)),
(Instruction::jump(1, true), Span(31, 33)), (Instruction::jump(1, true), Span(31, 33)),
( (Instruction::get_local(3, 1), Span(34, 35)),
Instruction::get_local(Destination::Register(3), 1),
Span(34, 35)
),
(Instruction::r#return(true), Span(35, 35)), (Instruction::r#return(true), Span(35, 35)),
], ],
vec![ConcreteValue::string("a"), ConcreteValue::string("b")], vec![ConcreteValue::string("a"), ConcreteValue::string("b")],
vec![ vec![
Local::new(0, Type::Boolean, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Boolean, false, Scope::default()) Local::new(1, 1, false, Scope::default())
] ]
)) ))
); );
@ -199,40 +143,19 @@ fn true_and_true_and_true() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, true, false), Span(8, 12)),
Instruction::load_boolean(Destination::Register(0), true, false), (Instruction::load_boolean(1, true, false), Span(22, 26)),
Span(8, 12) (Instruction::load_boolean(2, true, false), Span(36, 40)),
), (Instruction::get_local(3, 0), Span(42, 43)),
(Instruction::define_local(0, 0, false), Span(4, 5)), (Instruction::test(Argument::Register(0), true), Span(44, 46)),
(
Instruction::load_boolean(Destination::Register(1), true, false),
Span(22, 26)
),
(Instruction::define_local(1, 1, false), Span(18, 19)),
(
Instruction::load_boolean(Destination::Register(2), true, false),
Span(36, 40)
),
(Instruction::define_local(2, 2, false), Span(32, 33)),
(
Instruction::get_local(Destination::Register(3), 0),
Span(42, 43)
),
(Instruction::test(Argument::Local(0), true), Span(44, 46)),
(Instruction::jump(1, true), Span(44, 46)), (Instruction::jump(1, true), Span(44, 46)),
( (Instruction::get_local(4, 1), Span(47, 48)),
Instruction::get_local(Destination::Register(4), 1), (Instruction::test(Argument::Register(1), true), Span(49, 51)),
Span(47, 48)
),
(Instruction::test(Argument::Local(1), true), Span(49, 51)),
(Instruction::jump(1, true), Span(49, 51)), (Instruction::jump(1, true), Span(49, 51)),
( (Instruction::get_local(5, 2), Span(52, 53)),
Instruction::get_local(Destination::Register(5), 2),
Span(52, 53)
),
(Instruction::r#return(true), Span(53, 53)), (Instruction::r#return(true), Span(53, 53)),
], ],
vec![ vec![
@ -241,9 +164,9 @@ fn true_and_true_and_true() {
ConcreteValue::string("c") ConcreteValue::string("c")
], ],
vec![ vec![
Local::new(0, Type::Boolean, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Boolean, false, Scope::default()), Local::new(1, 1, false, Scope::default()),
Local::new(2, Type::Boolean, false, Scope::default()) Local::new(2, 2, false, Scope::default())
] ]
)) ))
); );
@ -262,40 +185,19 @@ fn false_and_false_and_false() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, false, false), Span(8, 13)),
Instruction::load_boolean(Destination::Register(0), false, false), (Instruction::load_boolean(1, false, false), Span(23, 28)),
Span(8, 13) (Instruction::load_boolean(2, false, false), Span(38, 43)),
), (Instruction::get_local(3, 0), Span(45, 46)),
(Instruction::define_local(0, 0, false), Span(4, 5)), (Instruction::test(Argument::Register(0), true), Span(47, 49)),
(
Instruction::load_boolean(Destination::Register(1), false, false),
Span(23, 28)
),
(Instruction::define_local(1, 1, false), Span(19, 20)),
(
Instruction::load_boolean(Destination::Register(2), false, false),
Span(38, 43)
),
(Instruction::define_local(2, 2, false), Span(34, 35)),
(
Instruction::get_local(Destination::Register(3), 0),
Span(45, 46)
),
(Instruction::test(Argument::Local(0), true), Span(47, 49)),
(Instruction::jump(1, true), Span(47, 49)), (Instruction::jump(1, true), Span(47, 49)),
( (Instruction::get_local(4, 1), Span(50, 51)),
Instruction::get_local(Destination::Register(4), 1), (Instruction::test(Argument::Register(1), true), Span(52, 54)),
Span(50, 51)
),
(Instruction::test(Argument::Local(1), true), Span(52, 54)),
(Instruction::jump(1, true), Span(52, 54)), (Instruction::jump(1, true), Span(52, 54)),
( (Instruction::get_local(5, 2), Span(55, 56)),
Instruction::get_local(Destination::Register(5), 2),
Span(55, 56)
),
(Instruction::r#return(true), Span(56, 56)), (Instruction::r#return(true), Span(56, 56)),
], ],
vec![ vec![
@ -304,9 +206,9 @@ fn false_and_false_and_false() {
ConcreteValue::string("c") ConcreteValue::string("c")
], ],
vec![ vec![
Local::new(0, Type::Boolean, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Boolean, false, Scope::default()), Local::new(1, 1, false, Scope::default()),
Local::new(2, Type::Boolean, false, Scope::default()) Local::new(2, 2, false, Scope::default())
] ]
)) ))
); );
@ -325,40 +227,22 @@ fn true_and_true_or_false() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, true, false), Span(8, 12)),
Instruction::load_boolean(Destination::Register(0), true, false), (Instruction::load_boolean(1, true, false), Span(22, 26)),
Span(8, 12) (Instruction::load_boolean(2, false, false), Span(36, 41)),
), (Instruction::get_local(3, 0), Span(43, 44)),
(Instruction::define_local(0, 0, false), Span(4, 5)), (Instruction::test(Argument::Register(0), true), Span(45, 47)),
(
Instruction::load_boolean(Destination::Register(1), true, false),
Span(22, 26)
),
(Instruction::define_local(1, 1, false), Span(18, 19)),
(
Instruction::load_boolean(Destination::Register(2), false, false),
Span(36, 41)
),
(Instruction::define_local(2, 2, false), Span(32, 33)),
(
Instruction::get_local(Destination::Register(3), 0),
Span(43, 44)
),
(Instruction::test(Argument::Local(0), true), Span(45, 47)),
(Instruction::jump(1, true), Span(45, 47)), (Instruction::jump(1, true), Span(45, 47)),
(Instruction::get_local(4, 1), Span(48, 49)),
( (
Instruction::get_local(Destination::Register(4), 1), Instruction::test(Argument::Register(1), false),
Span(48, 49) Span(50, 52)
), ),
(Instruction::test(Argument::Local(1), false), Span(50, 52)),
(Instruction::jump(1, true), Span(50, 52)), (Instruction::jump(1, true), Span(50, 52)),
( (Instruction::get_local(5, 2), Span(53, 54)),
Instruction::get_local(Destination::Register(5), 2),
Span(53, 54)
),
(Instruction::r#return(true), Span(54, 54)), (Instruction::r#return(true), Span(54, 54)),
], ],
vec![ vec![
@ -367,9 +251,9 @@ fn true_and_true_or_false() {
ConcreteValue::string("c") ConcreteValue::string("c")
], ],
vec![ vec![
Local::new(0, Type::Boolean, false, Scope::default()), Local::new(0, 0, false, Scope::default()),
Local::new(1, Type::Boolean, false, Scope::default()), Local::new(1, 1, false, Scope::default()),
Local::new(2, Type::Boolean, false, Scope::default()) Local::new(2, 2, false, Scope::default())
] ]
)) ))
); );

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

@ -11,32 +11,21 @@ fn r#while() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
(Instruction::load_constant(0, 0, false), Span(12, 13)),
( (
Instruction::load_constant(Destination::Register(0), 0, false), Instruction::less(0, true, Argument::Register(0), Argument::Constant(2)),
Span(12, 13)
),
(Instruction::define_local(0, 0, true), Span(8, 9)),
(
Instruction::less(true, Argument::Local(0), Argument::Constant(2)),
Span(23, 24) Span(23, 24)
), ),
(Instruction::jump(2, true), Span(41, 42)), (Instruction::jump(2, true), Span(41, 42)),
( (
Instruction::add( Instruction::add(0, Argument::Register(0), Argument::Constant(3)),
Destination::Local(0),
Argument::Local(0),
Argument::Constant(3)
),
Span(35, 36) Span(35, 36)
), ),
(Instruction::jump(3, false), Span(41, 42)), (Instruction::jump(3, false), Span(41, 42)),
( (Instruction::get_local(1, 0), Span(41, 42)),
Instruction::get_local(Destination::Register(1), 0),
Span(41, 42)
),
(Instruction::r#return(true), Span(42, 42)), (Instruction::r#return(true), Span(42, 42)),
], ],
vec![ vec![
@ -45,7 +34,7 @@ fn r#while() {
ConcreteValue::Integer(5), ConcreteValue::Integer(5),
ConcreteValue::Integer(1), ConcreteValue::Integer(1),
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, 0, true, Scope::default())]
)), )),
); );

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

@ -11,15 +11,11 @@ fn add_bytes() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Byte), return_type: Type::Byte,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(5, 6) Span(5, 6)
), ),
(Instruction::r#return(true), Span(11, 11)) (Instruction::r#return(true), Span(11, 11))
@ -43,15 +39,11 @@ fn add_bytes_saturate() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Byte), return_type: Type::Byte,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(5, 6) Span(5, 6)
), ),
(Instruction::r#return(true), Span(11, 11)) (Instruction::r#return(true), Span(11, 11))
@ -75,15 +67,11 @@ fn add_characters() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::String), return_type: Type::String,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(4, 5) Span(4, 5)
), ),
(Instruction::r#return(true), Span(9, 9)) (Instruction::r#return(true), Span(9, 9))
@ -107,15 +95,11 @@ fn add_character_and_string() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::String), return_type: Type::String,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(4, 5) Span(4, 5)
), ),
(Instruction::r#return(true), Span(9, 9)) (Instruction::r#return(true), Span(9, 9))
@ -139,15 +123,11 @@ fn add_floats() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Float), return_type: Type::Float,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(4, 5) Span(4, 5)
), ),
(Instruction::r#return(true), Span(9, 9)) (Instruction::r#return(true), Span(9, 9))
@ -171,15 +151,11 @@ fn add_floats_saturatate() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Float), return_type: Type::Float,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(24, 25) Span(24, 25)
), ),
(Instruction::r#return(true), Span(36, 36)) (Instruction::r#return(true), Span(36, 36))
@ -206,15 +182,11 @@ fn add_integers() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(2, 3) Span(2, 3)
), ),
(Instruction::r#return(true), Span(5, 5)) (Instruction::r#return(true), Span(5, 5))
@ -238,15 +210,11 @@ fn add_integers_saturate() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(20, 21) Span(20, 21)
), ),
(Instruction::r#return(true), Span(23, 23)) (Instruction::r#return(true), Span(23, 23))
@ -270,15 +238,11 @@ fn add_strings() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::String), return_type: Type::String,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(10, 11) Span(10, 11)
), ),
(Instruction::r#return(true), Span(20, 20)) (Instruction::r#return(true), Span(20, 20))
@ -303,15 +267,11 @@ fn add_string_and_character() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::String), return_type: Type::String,
}, },
vec![ vec![
( (
Instruction::add( Instruction::add(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(4, 5) Span(4, 5)
), ),
(Instruction::r#return(true), Span(9, 9)) (Instruction::r#return(true), Span(9, 9))

21
dust-lang/tests/math_add_assign.rs
View File

@ -11,26 +11,15 @@ fn add_assign() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
(Instruction::load_constant(0, 0, false), Span(12, 13)),
( (
Instruction::load_constant(Destination::Register(0), 0, false), Instruction::add(0, Argument::Register(0), Argument::Constant(2)),
Span(12, 13)
),
(Instruction::define_local(0, 0, true), Span(8, 9)),
(
Instruction::add(
Destination::Local(0),
Argument::Local(0),
Argument::Constant(2)
),
Span(17, 19) Span(17, 19)
), ),
( (Instruction::get_local(1, 0), Span(23, 24)),
Instruction::get_local(Destination::Register(1), 0),
Span(23, 24)
),
(Instruction::r#return(true), Span(24, 24)) (Instruction::r#return(true), Span(24, 24))
], ],
vec![ vec![
@ -38,7 +27,7 @@ fn add_assign() {
ConcreteValue::string("a"), ConcreteValue::string("a"),
ConcreteValue::Integer(2) ConcreteValue::Integer(2)
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, 0, true, Scope::default())]
)) ))
); );

54
dust-lang/tests/math_add_errors.rs
View File

@ -6,7 +6,7 @@ fn add_boolean_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddType { error: CompileError::CannotAddType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(0, 4) position: Span(0, 4)
@ -22,7 +22,7 @@ fn add_boolean_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddType { error: CompileError::CannotAddType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(4, 8) position: Span(4, 8)
@ -38,12 +38,12 @@ fn add_function_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddType { error: CompileError::CannotAddType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(0, 6) position: Span(0, 6)
}, },
@ -58,12 +58,12 @@ fn add_function_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddType { error: CompileError::CannotAddType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(4, 10) position: Span(4, 10)
}, },
@ -78,7 +78,7 @@ fn add_list_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddType { error: CompileError::CannotAddType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(0, 6) position: Span(0, 6)
@ -94,7 +94,7 @@ fn add_list_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddType { error: CompileError::CannotAddType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(4, 10) position: Span(4, 10)
@ -121,7 +121,7 @@ fn add_byte_and_character() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Byte, left_type: Type::Byte,
right_type: Type::Character, right_type: Type::Character,
@ -138,7 +138,7 @@ fn add_byte_and_integer() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Byte, left_type: Type::Byte,
right_type: Type::Integer, right_type: Type::Integer,
@ -155,7 +155,7 @@ fn add_byte_and_string() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Byte, left_type: Type::Byte,
right_type: Type::String, right_type: Type::String,
@ -172,7 +172,7 @@ fn add_character_and_byte() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Character, left_type: Type::Character,
right_type: Type::Byte, right_type: Type::Byte,
@ -189,7 +189,7 @@ fn add_character_and_float() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Character, left_type: Type::Character,
right_type: Type::Float, right_type: Type::Float,
@ -206,7 +206,7 @@ fn add_character_and_integer() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Character, left_type: Type::Character,
right_type: Type::Integer, right_type: Type::Integer,
@ -223,7 +223,7 @@ fn add_float_and_byte() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Float, left_type: Type::Float,
right_type: Type::Byte, right_type: Type::Byte,
@ -240,7 +240,7 @@ fn add_float_and_character() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Float, left_type: Type::Float,
right_type: Type::Character, right_type: Type::Character,
@ -257,7 +257,7 @@ fn add_float_and_integer() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Float, left_type: Type::Float,
right_type: Type::Integer, right_type: Type::Integer,
@ -274,7 +274,7 @@ fn add_float_and_string() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Float, left_type: Type::Float,
right_type: Type::String, right_type: Type::String,
@ -291,7 +291,7 @@ fn add_integer_and_byte() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Integer, left_type: Type::Integer,
right_type: Type::Byte, right_type: Type::Byte,
@ -308,7 +308,7 @@ fn add_integer_and_character() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Integer, left_type: Type::Integer,
right_type: Type::Character, right_type: Type::Character,
@ -325,7 +325,7 @@ fn add_integer_and_float() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Integer, left_type: Type::Integer,
right_type: Type::Float, right_type: Type::Float,
@ -342,7 +342,7 @@ fn add_integer_and_string() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::Integer, left_type: Type::Integer,
right_type: Type::String, right_type: Type::String,
@ -359,7 +359,7 @@ fn add_string_and_byte() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::String, left_type: Type::String,
right_type: Type::Byte, right_type: Type::Byte,
@ -376,7 +376,7 @@ fn add_string_and_float() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::String, left_type: Type::String,
right_type: Type::Float, right_type: Type::Float,
@ -393,7 +393,7 @@ fn add_string_and_integer() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotAddArguments { error: CompileError::CannotAddArguments {
left_type: Type::String, left_type: Type::String,
right_type: Type::Integer, right_type: Type::Integer,

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

@ -11,15 +11,11 @@ fn divide_bytes() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Byte), return_type: Type::Byte,
}, },
vec![ vec![
( (
Instruction::divide( Instruction::divide(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(5, 6) Span(5, 6)
), ),
(Instruction::r#return(true), Span(11, 11)) (Instruction::r#return(true), Span(11, 11))
@ -43,15 +39,11 @@ fn divide_floats() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Float), return_type: Type::Float,
}, },
vec![ vec![
( (
Instruction::divide( Instruction::divide(0, Argument::Constant(0), Argument::Constant(0)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(0)
),
Span(4, 5) Span(4, 5)
), ),
(Instruction::r#return(true), Span(9, 9)) (Instruction::r#return(true), Span(9, 9))
@ -75,15 +67,11 @@ fn divide_integers() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (
Instruction::divide( Instruction::divide(0, Argument::Constant(0), Argument::Constant(0)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(0)
),
Span(2, 3) Span(2, 3)
), ),
(Instruction::r#return(true), Span(5, 5)) (Instruction::r#return(true), Span(5, 5))

21
dust-lang/tests/math_divide_assign.rs
View File

@ -11,30 +11,19 @@ fn divide_assign() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
(Instruction::load_constant(0, 0, false), Span(12, 13)),
( (
Instruction::load_constant(Destination::Register(0), 0, false), Instruction::divide(0, Argument::Register(0), Argument::Constant(0)),
Span(12, 13)
),
(Instruction::define_local(0, 0, true), Span(8, 9)),
(
Instruction::divide(
Destination::Local(0),
Argument::Local(0),
Argument::Constant(0)
),
Span(17, 19) Span(17, 19)
), ),
( (Instruction::get_local(1, 0), Span(23, 24)),
Instruction::get_local(Destination::Register(1), 0),
Span(23, 24)
),
(Instruction::r#return(true), Span(24, 24)) (Instruction::r#return(true), Span(24, 24))
], ],
vec![ConcreteValue::Integer(2), ConcreteValue::string("a")], vec![ConcreteValue::Integer(2), ConcreteValue::string("a")],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, 0, true, Scope::default())]
)) ))
); );

34
dust-lang/tests/math_divide_errors.rs
View File

@ -6,7 +6,7 @@ fn divide_boolean_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(0, 4) position: Span(0, 4)
@ -22,7 +22,7 @@ fn divide_boolean_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(4, 8) position: Span(4, 8)
@ -38,7 +38,7 @@ fn divide_character_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(0, 3) position: Span(0, 3)
@ -54,7 +54,7 @@ fn divide_character_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(4, 7) position: Span(4, 7)
@ -70,7 +70,7 @@ fn divide_float_and_character() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(6, 9) position: Span(6, 9)
@ -86,7 +86,7 @@ fn divide_float_and_integer() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideArguments { error: CompileError::CannotDivideArguments {
left_type: Type::Float, left_type: Type::Float,
right_type: Type::Integer, right_type: Type::Integer,
@ -103,12 +103,12 @@ fn divide_function_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(0, 6) position: Span(0, 6)
}, },
@ -123,12 +123,12 @@ fn divide_function_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(4, 10) position: Span(4, 10)
}, },
@ -143,7 +143,7 @@ fn divide_integer_and_float() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideArguments { error: CompileError::CannotDivideArguments {
left_type: Type::Integer, left_type: Type::Integer,
right_type: Type::Float, right_type: Type::Float,
@ -160,7 +160,7 @@ fn divide_list_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(0, 6) position: Span(0, 6)
@ -176,7 +176,7 @@ fn divide_list_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(4, 10) position: Span(4, 10)
@ -202,7 +202,7 @@ fn divide_string_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::String, argument_type: Type::String,
position: Span(0, 7) position: Span(0, 7)
@ -218,7 +218,7 @@ fn divide_string_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotDivideType { error: CompileError::CannotDivideType {
argument_type: Type::String, argument_type: Type::String,
position: Span(4, 11) position: Span(4, 11)

16
dust-lang/tests/math_modulo.rs
View File

@ -11,15 +11,11 @@ fn modulo_floats() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Float), return_type: Type::Float,
}, },
vec![ vec![
( (
Instruction::modulo( Instruction::modulo(0, Argument::Constant(0), Argument::Constant(0)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(0)
),
Span(4, 5) Span(4, 5)
), ),
(Instruction::r#return(true), Span(9, 9)) (Instruction::r#return(true), Span(9, 9))
@ -43,15 +39,11 @@ fn modulo_integers() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (
Instruction::modulo( Instruction::modulo(0, Argument::Constant(0), Argument::Constant(0)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(0)
),
Span(2, 3) Span(2, 3)
), ),
(Instruction::r#return(true), Span(5, 5)) (Instruction::r#return(true), Span(5, 5))

34
dust-lang/tests/math_modulo_errors.rs
View File

@ -6,7 +6,7 @@ fn modulo_boolean_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(0, 4) position: Span(0, 4)
@ -22,7 +22,7 @@ fn modulo_boolean_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(4, 8) position: Span(4, 8)
@ -38,7 +38,7 @@ fn modulo_character_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(0, 3) position: Span(0, 3)
@ -54,7 +54,7 @@ fn modulo_character_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(4, 7) position: Span(4, 7)
@ -70,7 +70,7 @@ fn modulo_float_and_character() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(6, 9) position: Span(6, 9)
@ -86,7 +86,7 @@ fn modulo_float_and_integer() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloArguments { error: CompileError::CannotModuloArguments {
left_type: Type::Float, left_type: Type::Float,
right_type: Type::Integer, right_type: Type::Integer,
@ -103,12 +103,12 @@ fn modulo_function_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(0, 6) position: Span(0, 6)
}, },
@ -123,12 +123,12 @@ fn modulo_function_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(4, 10) position: Span(4, 10)
}, },
@ -143,7 +143,7 @@ fn modulo_integer_and_float() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloArguments { error: CompileError::CannotModuloArguments {
left_type: Type::Integer, left_type: Type::Integer,
right_type: Type::Float, right_type: Type::Float,
@ -160,7 +160,7 @@ fn modulo_list_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(0, 6) position: Span(0, 6)
@ -176,7 +176,7 @@ fn modulo_list_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(4, 10) position: Span(4, 10)
@ -202,7 +202,7 @@ fn modulo_string_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::String, argument_type: Type::String,
position: Span(0, 7) position: Span(0, 7)
@ -218,7 +218,7 @@ fn modulo_string_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotModuloType { error: CompileError::CannotModuloType {
argument_type: Type::String, argument_type: Type::String,
position: Span(4, 11) position: Span(4, 11)

16
dust-lang/tests/math_multiply.rs
View File

@ -11,15 +11,11 @@ fn multiply_floats() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Float), return_type: Type::Float
}, },
vec![ vec![
( (
Instruction::multiply( Instruction::multiply(0, Argument::Constant(0), Argument::Constant(0)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(0)
),
Span(4, 5) Span(4, 5)
), ),
(Instruction::r#return(true), Span(9, 9)), (Instruction::r#return(true), Span(9, 9)),
@ -43,15 +39,11 @@ fn multiply_integers() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (
Instruction::multiply( Instruction::multiply(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(2, 3) Span(2, 3)
), ),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),

21
dust-lang/tests/math_multiply_assign.rs
View File

@ -11,26 +11,15 @@ fn multiply_assign() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
(Instruction::load_constant(0, 0, false), Span(12, 13)),
( (
Instruction::load_constant(Destination::Register(0), 0, false), Instruction::multiply(0, Argument::Register(0), Argument::Constant(2)),
Span(12, 13)
),
(Instruction::define_local(0, 0, true), Span(8, 9)),
(
Instruction::multiply(
Destination::Local(0),
Argument::Local(0),
Argument::Constant(2)
),
Span(17, 19) Span(17, 19)
), ),
( (Instruction::get_local(1, 0), Span(22, 23)),
Instruction::get_local(Destination::Register(1), 0),
Span(22, 23)
),
(Instruction::r#return(true), Span(23, 23)) (Instruction::r#return(true), Span(23, 23))
], ],
vec![ vec![
@ -38,7 +27,7 @@ fn multiply_assign() {
ConcreteValue::string("a"), ConcreteValue::string("a"),
ConcreteValue::Integer(3) ConcreteValue::Integer(3)
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, 0, true, Scope::default())]
)) ))
); );

34
dust-lang/tests/math_multiply_errors.rs
View File

@ -6,7 +6,7 @@ fn multiply_boolean_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(0, 4) position: Span(0, 4)
@ -22,7 +22,7 @@ fn multiply_boolean_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(4, 8) position: Span(4, 8)
@ -38,7 +38,7 @@ fn multiply_character_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(0, 3) position: Span(0, 3)
@ -54,7 +54,7 @@ fn multiply_character_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(4, 7) position: Span(4, 7)
@ -70,7 +70,7 @@ fn multiply_float_and_character() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(6, 9) position: Span(6, 9)
@ -86,7 +86,7 @@ fn multiply_float_and_integer() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyArguments { error: CompileError::CannotMultiplyArguments {
left_type: Type::Float, left_type: Type::Float,
right_type: Type::Integer, right_type: Type::Integer,
@ -103,12 +103,12 @@ fn multiply_function_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(0, 6) position: Span(0, 6)
}, },
@ -123,12 +123,12 @@ fn multiply_function_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(4, 10) position: Span(4, 10)
}, },
@ -143,7 +143,7 @@ fn multiply_integer_and_float() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyArguments { error: CompileError::CannotMultiplyArguments {
left_type: Type::Integer, left_type: Type::Integer,
right_type: Type::Float, right_type: Type::Float,
@ -160,7 +160,7 @@ fn multiply_list_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(0, 6) position: Span(0, 6)
@ -176,7 +176,7 @@ fn multiply_list_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(4, 10) position: Span(4, 10)
@ -202,7 +202,7 @@ fn multiply_string_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::String, argument_type: Type::String,
position: Span(0, 7) position: Span(0, 7)
@ -218,7 +218,7 @@ fn multiply_string_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotMultiplyType { error: CompileError::CannotMultiplyType {
argument_type: Type::String, argument_type: Type::String,
position: Span(4, 11) position: Span(4, 11)

32
dust-lang/tests/math_subtract.rs
View File

@ -11,15 +11,11 @@ fn subtract_floats() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Float), return_type: Type::Float,
}, },
vec![ vec![
( (
Instruction::subtract( Instruction::subtract(0, Argument::Constant(0), Argument::Constant(0)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(0)
),
Span(4, 5) Span(4, 5)
), ),
(Instruction::r#return(true), Span(9, 9)), (Instruction::r#return(true), Span(9, 9)),
@ -43,15 +39,11 @@ fn subtract_floats_saturate() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Float), return_type: Type::Float,
}, },
vec![ vec![
( (
Instruction::subtract( Instruction::subtract(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(25, 26) Span(25, 26)
), ),
(Instruction::r#return(true), Span(36, 36)), (Instruction::r#return(true), Span(36, 36)),
@ -78,15 +70,11 @@ fn subtract_integers() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (
Instruction::subtract( Instruction::subtract(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(2, 3) Span(2, 3)
), ),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
@ -110,15 +98,11 @@ fn subtract_integers_saturate() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (
Instruction::subtract( Instruction::subtract(0, Argument::Constant(0), Argument::Constant(1)),
Destination::Register(0),
Argument::Constant(0),
Argument::Constant(1)
),
Span(21, 22) Span(21, 22)
), ),
(Instruction::r#return(true), Span(24, 24)), (Instruction::r#return(true), Span(24, 24)),

21
dust-lang/tests/math_subtract_assign.rs
View File

@ -11,26 +11,15 @@ fn subtract_assign() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
(Instruction::load_constant(0, 0, false), Span(12, 14)),
( (
Instruction::load_constant(Destination::Register(0), 0, false), Instruction::subtract(0, Argument::Register(0), Argument::Constant(2)),
Span(12, 14)
),
(Instruction::define_local(0, 0, true), Span(8, 9)),
(
Instruction::subtract(
Destination::Local(0),
Argument::Local(0),
Argument::Constant(2)
),
Span(18, 20) Span(18, 20)
), ),
( (Instruction::get_local(1, 0), Span(24, 25)),
Instruction::get_local(Destination::Register(1), 0),
Span(24, 25)
),
(Instruction::r#return(true), Span(25, 25)), (Instruction::r#return(true), Span(25, 25)),
], ],
vec![ vec![
@ -38,7 +27,7 @@ fn subtract_assign() {
ConcreteValue::string("x"), ConcreteValue::string("x"),
ConcreteValue::Integer(2) ConcreteValue::Integer(2)
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, 0, true, Scope::default())]
)), )),
); );

34
dust-lang/tests/math_subtract_errors.rs
View File

@ -6,7 +6,7 @@ fn subtract_boolean_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(0, 4) position: Span(0, 4)
@ -22,7 +22,7 @@ fn subtract_boolean_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::Boolean, argument_type: Type::Boolean,
position: Span(4, 8) position: Span(4, 8)
@ -38,7 +38,7 @@ fn subtract_character_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(0, 3) position: Span(0, 3)
@ -54,7 +54,7 @@ fn subtract_character_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(4, 7) position: Span(4, 7)
@ -70,7 +70,7 @@ fn subtract_float_and_character() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::Character, argument_type: Type::Character,
position: Span(6, 9) position: Span(6, 9)
@ -86,7 +86,7 @@ fn subtract_float_and_integer() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractArguments { error: CompileError::CannotSubtractArguments {
left_type: Type::Float, left_type: Type::Float,
right_type: Type::Integer, right_type: Type::Integer,
@ -103,12 +103,12 @@ fn subtract_function_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(0, 6) position: Span(0, 6)
}, },
@ -123,12 +123,12 @@ fn subtract_function_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::Function(FunctionType { argument_type: Type::function(FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None) return_type: Type::None
}), }),
position: Span(4, 10) position: Span(4, 10)
}, },
@ -143,7 +143,7 @@ fn subtract_integer_and_float() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractArguments { error: CompileError::CannotSubtractArguments {
left_type: Type::Integer, left_type: Type::Integer,
right_type: Type::Float, right_type: Type::Float,
@ -160,7 +160,7 @@ fn subtract_list_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(0, 6) position: Span(0, 6)
@ -176,7 +176,7 @@ fn subtract_list_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::List(Box::new(Type::Integer)), argument_type: Type::List(Box::new(Type::Integer)),
position: Span(4, 10) position: Span(4, 10)
@ -202,7 +202,7 @@ fn subtract_string_left() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::String, argument_type: Type::String,
position: Span(0, 7) position: Span(0, 7)
@ -218,7 +218,7 @@ fn subtract_string_right() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::CannotSubtractType { error: CompileError::CannotSubtractType {
argument_type: Type::String, argument_type: Type::String,
position: Span(4, 11) position: Span(4, 11)

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

@ -11,19 +11,13 @@ fn panic() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None), return_type: Type::None,
}, },
vec![ vec![
(Instruction::load_constant(0, 0, false), Span(6, 22)),
(Instruction::load_constant(1, 1, false), Span(24, 26)),
( (
Instruction::load_constant(Destination::Register(0), 0, false), Instruction::call_native(2, NativeFunction::Panic, 2),
Span(6, 22)
),
(
Instruction::load_constant(Destination::Register(1), 1, false),
Span(24, 26)
),
(
Instruction::call_native(Destination::Register(2), NativeFunction::Panic, 2),
Span(0, 27) Span(0, 27)
), ),
(Instruction::r#return(false), Span(27, 27)) (Instruction::r#return(false), Span(27, 27))
@ -38,7 +32,7 @@ fn panic() {
assert_eq!( assert_eq!(
run(source), run(source),
Err(CreateReport::Runtime { Err(DustError::Runtime {
error: VmError::NativeFunction(NativeFunctionError::Panic { error: VmError::NativeFunction(NativeFunctionError::Panic {
message: Some("Goodbye world! 42".to_string()), message: Some("Goodbye world! 42".to_string()),
position: Span(0, 27) position: Span(0, 27)
@ -59,15 +53,12 @@ fn to_string() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::String), return_type: Type::String,
}, },
vec![ vec![
(Instruction::load_constant(0, 0, false), Span(10, 12)),
( (
Instruction::load_constant(Destination::Register(0), 0, false), Instruction::call_native(1, NativeFunction::ToString, 1),
Span(10, 12)
),
(
Instruction::call_native(Destination::Register(1), NativeFunction::ToString, 1),
Span(0, 13) Span(0, 13)
), ),
(Instruction::r#return(true), Span(13, 13)) (Instruction::r#return(true), Span(13, 13))

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

@ -33,34 +33,14 @@ fn block_scope() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None), return_type: Type::None,
}, },
vec![ vec![
( (Instruction::load_constant(0, 0, false), Span(17, 18)),
Instruction::load_constant(Destination::Register(0), 0, false), (Instruction::load_constant(1, 2, false), Span(50, 52)),
Span(17, 18) (Instruction::load_constant(2, 4, false), Span(92, 93)),
), (Instruction::load_constant(3, 6, false), Span(129, 130)),
(Instruction::define_local(0, 0, false), Span(13, 14)), (Instruction::load_constant(4, 4, false), Span(158, 159)),
(
Instruction::load_constant(Destination::Register(1), 2, false),
Span(50, 52)
),
(Instruction::define_local(1, 1, false), Span(46, 47)),
(
Instruction::load_constant(Destination::Register(2), 4, false),
Span(92, 93)
),
(Instruction::define_local(2, 2, false), Span(88, 89)),
(
Instruction::load_constant(Destination::Register(3), 6, false),
Span(129, 130)
),
(Instruction::define_local(3, 3, false), Span(125, 126)),
(
Instruction::load_constant(Destination::Register(4), 4, false),
Span(158, 159)
),
(Instruction::define_local(4, 4, false), Span(154, 155)),
(Instruction::r#return(false), Span(165, 165)) (Instruction::r#return(false), Span(165, 165))
], ],
vec![ vec![
@ -75,11 +55,11 @@ fn block_scope() {
ConcreteValue::string("e"), ConcreteValue::string("e"),
], ],
vec![ vec![
Local::new(1, Type::Integer, false, Scope::new(0, 0)), Local::new(1, 0, false, Scope::new(0, 0)),
Local::new(3, Type::Integer, false, Scope::new(1, 1)), Local::new(3, 2, false, Scope::new(1, 1)),
Local::new(5, Type::Integer, false, Scope::new(2, 2)), Local::new(5, 4, false, Scope::new(2, 2)),
Local::new(7, Type::Integer, false, Scope::new(1, 1)), Local::new(7, 6, false, Scope::new(1, 1)),
Local::new(8, Type::Integer, false, Scope::new(0, 0)), Local::new(8, 7, false, Scope::new(0, 0)),
] ]
)), )),
); );
@ -116,54 +96,18 @@ fn multiple_block_scopes() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None), return_type: Type::None,
}, },
vec![ vec![
( (Instruction::load_constant(0, 0, false), Span(17, 18)),
Instruction::load_constant(Destination::Register(0), 0, false), (Instruction::load_constant(1, 2, false), Span(50, 52)),
Span(17, 18) (Instruction::load_constant(2, 4, false), Span(92, 93)),
), (Instruction::get_local(3, 1), Span(129, 130)),
(Instruction::define_local(0, 0, false), Span(13, 14)), (Instruction::get_local(4, 0), Span(158, 159)),
( (Instruction::load_constant(5, 2, false), Span(191, 193)),
Instruction::load_constant(Destination::Register(1), 2, false), (Instruction::load_constant(4, 4, false), Span(233, 234)),
Span(50, 52) (Instruction::get_local(7, 5), Span(270, 271)),
), (Instruction::get_local(8, 0), Span(299, 300)),
(Instruction::define_local(1, 1, false), Span(46, 47)),
(
Instruction::load_constant(Destination::Register(2), 4, false),
Span(92, 93)
),
(Instruction::define_local(2, 2, false), Span(88, 89)),
(
Instruction::get_local(Destination::Register(3), 1),
Span(129, 130)
),
(Instruction::define_local(3, 3, false), Span(125, 126)),
(
Instruction::get_local(Destination::Register(4), 0),
Span(158, 159)
),
(Instruction::define_local(4, 4, false), Span(154, 155)),
(
Instruction::load_constant(Destination::Register(5), 2, false),
Span(191, 193)
),
(Instruction::define_local(5, 5, false), Span(187, 188)),
(
Instruction::load_constant(Destination::Register(6), 4, false),
Span(233, 234)
),
(Instruction::define_local(6, 6, false), Span(229, 230)),
(
Instruction::get_local(Destination::Register(7), 5),
Span(270, 271)
),
(Instruction::define_local(7, 7, false), Span(266, 267)),
(
Instruction::get_local(Destination::Register(8), 0),
Span(299, 300)
),
(Instruction::define_local(8, 8, false), Span(295, 296)),
(Instruction::r#return(false), Span(306, 306)) (Instruction::r#return(false), Span(306, 306))
], ],
vec![ vec![
@ -178,15 +122,15 @@ fn multiple_block_scopes() {
ConcreteValue::string("e"), ConcreteValue::string("e"),
], ],
vec![ vec![
Local::new(1, Type::Integer, false, Scope::new(0, 0)), Local::new(1, 0, false, Scope::new(0, 0)),
Local::new(3, Type::Integer, false, Scope::new(1, 1)), Local::new(3, 2, false, Scope::new(1, 1)),
Local::new(5, Type::Integer, false, Scope::new(2, 2)), Local::new(5, 4, false, Scope::new(2, 2)),
Local::new(6, Type::Integer, false, Scope::new(1, 1)), Local::new(6, 5, false, Scope::new(1, 1)),
Local::new(7, Type::Integer, false, Scope::new(0, 0)), Local::new(7, 6, false, Scope::new(0, 0)),
Local::new(3, Type::Integer, false, Scope::new(1, 3)), Local::new(3, 1, false, Scope::new(1, 3)),
Local::new(5, Type::Integer, false, Scope::new(2, 4)), Local::new(5, 1, false, Scope::new(2, 4)),
Local::new(6, Type::Integer, false, Scope::new(1, 3)), Local::new(6, 1, false, Scope::new(1, 3)),
Local::new(8, Type::Integer, false, Scope::new(0, 0)), Local::new(8, 1, false, Scope::new(0, 0)),
] ]
)), )),
); );
@ -205,7 +149,7 @@ fn disallow_access_to_child_scope() {
assert_eq!( assert_eq!(
run(source), run(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::VariableOutOfScope { error: CompileError::VariableOutOfScope {
identifier: "x".to_string(), identifier: "x".to_string(),
position: Span(52, 53), position: Span(52, 53),
@ -230,7 +174,7 @@ fn disallow_access_to_child_scope_nested() {
assert_eq!( assert_eq!(
run(source), run(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::VariableOutOfScope { error: CompileError::VariableOutOfScope {
identifier: "x".to_string(), identifier: "x".to_string(),
position: Span(78, 79), position: Span(78, 79),
@ -255,7 +199,7 @@ fn disallow_access_to_sibling_scope() {
assert_eq!( assert_eq!(
run(source), run(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::VariableOutOfScope { error: CompileError::VariableOutOfScope {
identifier: "x".to_string(), identifier: "x".to_string(),
variable_scope: Scope::new(1, 1), variable_scope: Scope::new(1, 1),
@ -282,7 +226,7 @@ fn disallow_access_to_sibling_scope_nested() {
assert_eq!( assert_eq!(
run(source), run(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::VariableOutOfScope { error: CompileError::VariableOutOfScope {
identifier: "x".to_string(), identifier: "x".to_string(),
variable_scope: Scope::new(2, 2), variable_scope: Scope::new(2, 2),

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

@ -11,13 +11,10 @@ fn negate() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (Instruction::negate(0, Argument::Constant(0)), Span(0, 1)),
Instruction::negate(Destination::Register(0), Argument::Constant(0)),
Span(0, 1)
),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
], ],
vec![ConcreteValue::Integer(42)], vec![ConcreteValue::Integer(42)],
@ -39,17 +36,11 @@ fn not() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Boolean), return_type: Type::Boolean,
}, },
vec![ vec![
( (Instruction::load_boolean(0, true, false), Span(1, 5)),
Instruction::load_boolean(Destination::Register(0), true, false), (Instruction::not(1, Argument::Register(0)), Span(0, 1)),
Span(1, 5)
),
(
Instruction::not(Destination::Register(1), Argument::Register(0)),
Span(0, 1)
),
(Instruction::r#return(true), Span(5, 5)), (Instruction::r#return(true), Span(5, 5)),
], ],
vec![], vec![],

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

@ -11,18 +11,14 @@ fn define_local() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::None), return_type: Type::None,
}, },
vec![ vec![
( (Instruction::load_constant(0, 0, false), Span(8, 10)),
Instruction::load_constant(Destination::Register(0), 0, false),
Span(8, 10)
),
(Instruction::define_local(0, 0, false), Span(4, 5)),
(Instruction::r#return(false), Span(11, 11)) (Instruction::r#return(false), Span(11, 11))
], ],
vec![ConcreteValue::Integer(42), ConcreteValue::string("x")], vec![ConcreteValue::Integer(42), ConcreteValue::string("x")],
vec![Local::new(1, Type::Integer, false, Scope::default())] vec![Local::new(1, 0, false, Scope::default())]
)), )),
); );
@ -35,7 +31,7 @@ fn let_statement_expects_identifier() {
assert_eq!( assert_eq!(
compile(source), compile(source),
Err(CreateReport::Compile { Err(DustError::Compile {
error: CompileError::ExpectedToken { error: CompileError::ExpectedToken {
expected: TokenKind::Identifier, expected: TokenKind::Identifier,
found: Token::Integer("1").to_owned(), found: Token::Integer("1").to_owned(),
@ -57,23 +53,13 @@ fn set_local() {
FunctionType { FunctionType {
type_parameters: None, type_parameters: None,
value_parameters: None, value_parameters: None,
return_type: Box::new(Type::Integer), return_type: Type::Integer,
}, },
vec![ vec![
( (Instruction::load_constant(0, 0, false), Span(12, 14)),
Instruction::load_constant(Destination::Register(0), 0, false), (Instruction::load_constant(1, 2, false), Span(20, 22)),
Span(12, 14)
),
(Instruction::define_local(0, 0, true), Span(8, 9)),
(
Instruction::load_constant(Destination::Register(1), 2, false),
Span(20, 22)
),
(Instruction::set_local(1, 0), Span(16, 17)), (Instruction::set_local(1, 0), Span(16, 17)),
( (Instruction::get_local(2, 0), Span(24, 25)),
Instruction::get_local(Destination::Register(2), 0),
Span(24, 25)
),
(Instruction::r#return(true), Span(25, 25)), (Instruction::r#return(true), Span(25, 25)),
], ],
vec![ vec![
@ -81,7 +67,7 @@ fn set_local() {
ConcreteValue::string("x"), ConcreteValue::string("x"),
ConcreteValue::Integer(42) ConcreteValue::Integer(42)
], ],
vec![Local::new(1, Type::Integer, true, Scope::default())] vec![Local::new(1, 0, true, Scope::default())]
)), )),
); );