Syntax: fn type name
This commit is contained in:
@@ -330,7 +330,7 @@ trait_decl = {
|
||||
override_kw = { "override" ~ ("(" ~ expr_path ~ ")")? }
|
||||
|
||||
function_decl = {
|
||||
visibility? ~ override_kw? ~ "fn" ~ identifier ~ generics_decl? ~ "(" ~ method_args ~ ")" ~ type_expr? ~ (block | semicolon)
|
||||
visibility? ~ override_kw? ~ "fn" ~ ("void" | type_expr) ~ identifier ~ generics_decl? ~ "(" ~ method_args ~ ")" ~ (block | semicolon)
|
||||
}
|
||||
|
||||
// ======================================================
|
||||
|
||||
@@ -14,6 +14,11 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FunctionDecl {
|
||||
let mut inner = pair.into_inner();
|
||||
let visibility = Visibility::try_from(&mut inner);
|
||||
let is_override = consume_rule(&mut inner, Rule::override_kw).map(Override::try_from).transpose();
|
||||
|
||||
let return_type = consume_rule(&mut inner, Rule::type_expr)
|
||||
.map(TypeExpr::try_from)
|
||||
.transpose();
|
||||
|
||||
let name = Identifier::try_from(inner.next().unwrap());
|
||||
|
||||
let generics = consume_rule(&mut inner, Rule::generics_decl)
|
||||
@@ -59,10 +64,6 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FunctionDecl {
|
||||
})
|
||||
.unwrap_or_else(|| Ok(ParamList(self_param.into_iter().collect())));
|
||||
|
||||
let return_type = consume_rule(&mut inner, Rule::type_expr)
|
||||
.map(TypeExpr::try_from)
|
||||
.transpose();
|
||||
|
||||
let body = inner.next().map(Block::try_from).transpose();
|
||||
|
||||
ast_expr!(Self {
|
||||
|
||||
@@ -1,83 +0,0 @@
|
||||
pub module decl_test;
|
||||
|
||||
pub fn test_let_basic() {
|
||||
let x = 42;
|
||||
assert_eq!(x, 42);
|
||||
}
|
||||
|
||||
pub fn test_let_typed() {
|
||||
let x i32 = 42;
|
||||
assert_eq!(x, 42);
|
||||
|
||||
let s *str = "hello";
|
||||
assert_eq!(s, "hello");
|
||||
|
||||
let b bool = true;
|
||||
assert_eq!(b, true);
|
||||
|
||||
let f f64 = 3.14;
|
||||
assert_eq!(f, 3.14);
|
||||
}
|
||||
|
||||
pub fn test_let_mut() {
|
||||
let mut _x = 42;
|
||||
_x = 100;
|
||||
assert_eq!(_x, 100);
|
||||
}
|
||||
|
||||
pub fn test_let_tuple_destructure() {
|
||||
let [a, b] = (10, "hello");
|
||||
assert_eq!(a, 10);
|
||||
assert_eq!(b, "hello");
|
||||
}
|
||||
|
||||
pub fn test_let_nested_tuple() {
|
||||
let [a, [b, c]] = (1, (2, 3));
|
||||
assert_eq!(a, 1);
|
||||
assert_eq!(b, 2);
|
||||
assert_eq!(c, 3);
|
||||
}
|
||||
|
||||
pub fn test_let_pattern_irrefutable() {
|
||||
let x = 5;
|
||||
let [y, z] = (1, 2);
|
||||
assert_eq!(x, 5);
|
||||
assert_eq!(y, 1);
|
||||
assert_eq!(z, 2);
|
||||
}
|
||||
|
||||
pub fn test_multiple_decls() {
|
||||
let a = 1;
|
||||
let b = 2;
|
||||
let c = 3;
|
||||
assert_eq!(a + b + c, 6);
|
||||
}
|
||||
|
||||
pub fn test_let_with_type_and_init() {
|
||||
let x f64 = 10.0;
|
||||
assert_eq!(x, 10.0);
|
||||
}
|
||||
|
||||
pub fn test_string_literal() {
|
||||
let s = "hello, world!";
|
||||
assert_eq!(s.len(), 13);
|
||||
}
|
||||
|
||||
pub fn test_let_bool() {
|
||||
let t = true;
|
||||
let f = false;
|
||||
assert_eq!(t, !f);
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_let_basic();
|
||||
test_let_typed();
|
||||
test_let_mut();
|
||||
test_let_tuple_destructure();
|
||||
test_let_nested_tuple();
|
||||
test_let_pattern_irrefutable();
|
||||
test_multiple_decls();
|
||||
test_let_with_type_and_init();
|
||||
test_string_literal();
|
||||
test_let_bool();
|
||||
}
|
||||
@@ -1,152 +0,0 @@
|
||||
pub module expr_test;
|
||||
|
||||
pub fn test_literals() {
|
||||
assert_eq!(42, 42);
|
||||
assert_eq!(3.14, 3.14);
|
||||
assert_eq!(true, true);
|
||||
assert_eq!(false, false);
|
||||
assert_eq!("hello", "hello");
|
||||
}
|
||||
|
||||
pub fn test_tuples() {
|
||||
let t = (1, true, "three");
|
||||
assert_eq!(t.0, 1);
|
||||
assert_eq!(t.1, true);
|
||||
assert_eq!(t.2, "three");
|
||||
}
|
||||
|
||||
pub fn test_arrays() {
|
||||
let arr = [1, 2, 3];
|
||||
assert_eq!(arr[0], 1);
|
||||
assert_eq!(arr[1], 2);
|
||||
assert_eq!(arr[2], 3);
|
||||
}
|
||||
|
||||
pub fn test_array_repeat() {
|
||||
let arr = [0; 5];
|
||||
assert_eq!(arr[0], 0);
|
||||
assert_eq!(arr[4], 0);
|
||||
assert_eq!(arr.len(), 5);
|
||||
}
|
||||
|
||||
pub fn test_binary_arith() {
|
||||
assert_eq!(10 + 5, 15);
|
||||
assert_eq!(10 - 5, 5);
|
||||
assert_eq!(10 * 5, 50);
|
||||
assert_eq!(10 / 5, 2);
|
||||
assert_eq!(10 % 3, 1);
|
||||
}
|
||||
|
||||
pub fn test_binary_cmp() {
|
||||
assert_eq!(5 < 10, true);
|
||||
assert_eq!(10 <= 10, true);
|
||||
assert_eq!(10 > 5, true);
|
||||
assert_eq!(10 >= 10, true);
|
||||
assert_eq!(5 == 5, true);
|
||||
assert_eq!(5 != 10, true);
|
||||
}
|
||||
|
||||
pub fn test_binary_logic() {
|
||||
assert_eq!(true && true, true);
|
||||
assert_eq!(true && false, false);
|
||||
assert_eq!(true || false, true);
|
||||
assert_eq!(false || false, false);
|
||||
}
|
||||
|
||||
pub fn test_binary_bit() {
|
||||
assert_eq!(5 & 3, 1);
|
||||
assert_eq!(5 | 3, 7);
|
||||
assert_eq!(5 ^ 3, 6);
|
||||
assert_eq!(1 << 2, 4);
|
||||
assert_eq!(4 >> 1, 2);
|
||||
}
|
||||
|
||||
pub fn test_prefix() {
|
||||
let x = 42;
|
||||
assert_eq!(-x, -42);
|
||||
assert_eq!(!true, false);
|
||||
assert_eq!(!false, true);
|
||||
}
|
||||
|
||||
pub fn test_ref_deref() {
|
||||
let x = 42;
|
||||
let r = &x;
|
||||
assert_eq!(*r, 42);
|
||||
}
|
||||
|
||||
pub fn test_postfix_inc_dec() {
|
||||
let mut x = 5;
|
||||
x++;
|
||||
assert_eq!(x, 6);
|
||||
x--;
|
||||
assert_eq!(x, 5);
|
||||
}
|
||||
|
||||
pub fn test_as_cast() {
|
||||
let x = 42;
|
||||
assert_eq!(x as f64, 42.0);
|
||||
}
|
||||
|
||||
pub fn test_closure() {
|
||||
let add = fn(a, b) -> a + b;
|
||||
assert_eq!(add(2, 3), 5);
|
||||
}
|
||||
|
||||
pub fn test_block_expr() {
|
||||
let x = {
|
||||
let y = 10;
|
||||
y + 5
|
||||
};
|
||||
assert_eq!(x, 15);
|
||||
}
|
||||
|
||||
pub fn test_if_expr() {
|
||||
let x = if true { 1 } else { 2 };
|
||||
assert_eq!(x, 1);
|
||||
|
||||
let y = if false { 1 } else { 2 };
|
||||
assert_eq!(y, 2);
|
||||
}
|
||||
|
||||
pub fn test_range_expr() {
|
||||
let r = 0..5;
|
||||
let mut count = 0;
|
||||
for i in r {
|
||||
count++;
|
||||
}
|
||||
assert_eq!(count, 5);
|
||||
}
|
||||
|
||||
pub fn test_binary_assign() {
|
||||
let mut x = 10;
|
||||
x += 5;
|
||||
assert_eq!(x, 15);
|
||||
x -= 3;
|
||||
assert_eq!(x, 12);
|
||||
x *= 2;
|
||||
assert_eq!(x, 24);
|
||||
x /= 4;
|
||||
assert_eq!(x, 6);
|
||||
x %= 4;
|
||||
assert_eq!(x, 2);
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_literals();
|
||||
test_tuples();
|
||||
test_arrays();
|
||||
test_array_repeat();
|
||||
test_binary_arith();
|
||||
test_binary_cmp();
|
||||
test_binary_logic();
|
||||
test_binary_bit();
|
||||
test_prefix();
|
||||
test_ref_deref();
|
||||
test_postfix_inc_dec();
|
||||
test_as_cast();
|
||||
test_closure();
|
||||
test_block_expr();
|
||||
test_if_expr();
|
||||
test_range_expr();
|
||||
test_binary_assign();
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
pub module common;
|
||||
|
||||
pub fn test_package() {}
|
||||
@@ -1,167 +0,0 @@
|
||||
pub module statement_test;
|
||||
|
||||
pub fn test_var_decl() {
|
||||
let x = 42;
|
||||
assert_eq!(x, 42);
|
||||
|
||||
let y i32 = 10;
|
||||
assert_eq!(y, 10);
|
||||
|
||||
let name *str = "mist";
|
||||
assert_eq!(name, "mist");
|
||||
}
|
||||
|
||||
pub fn test_var_decl_with_init() {
|
||||
let mut x = 0;
|
||||
x = 5;
|
||||
assert_eq!(x, 5);
|
||||
}
|
||||
|
||||
pub fn test_if_statement() {
|
||||
let mut x = 0;
|
||||
|
||||
if true {
|
||||
x = 1;
|
||||
}
|
||||
assert_eq!(x, 1);
|
||||
|
||||
if false {
|
||||
x = 2;
|
||||
} else {
|
||||
x = 3;
|
||||
}
|
||||
assert_eq!(x, 3);
|
||||
}
|
||||
|
||||
pub fn test_if_else_if() {
|
||||
let mut x = 0;
|
||||
|
||||
if x == 1 {
|
||||
x = 10;
|
||||
} else if x == 0 {
|
||||
x = 20;
|
||||
} else {
|
||||
x = 30;
|
||||
}
|
||||
assert_eq!(x, 20);
|
||||
}
|
||||
|
||||
pub fn test_while_loop() {
|
||||
let mut count = 0;
|
||||
|
||||
while count < 5 {
|
||||
count++;
|
||||
}
|
||||
assert_eq!(count, 5);
|
||||
}
|
||||
|
||||
pub fn test_for_loop() {
|
||||
let mut sum = 0;
|
||||
|
||||
for i in 0..4 {
|
||||
sum += i;
|
||||
}
|
||||
assert_eq!(sum, 6);
|
||||
}
|
||||
|
||||
pub fn test_loop_stmt() {
|
||||
let mut count = 0;
|
||||
|
||||
loop {
|
||||
count++;
|
||||
if count >= 3 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_eq!(count, 3);
|
||||
}
|
||||
|
||||
pub fn test_break_continue() {
|
||||
let mut sum = 0;
|
||||
|
||||
for i in 0..10 {
|
||||
if i % 2 == 0 {
|
||||
continue;
|
||||
}
|
||||
if i >= 7 {
|
||||
break;
|
||||
}
|
||||
sum += i;
|
||||
}
|
||||
assert_eq!(sum, 1 + 3 + 5);
|
||||
}
|
||||
|
||||
pub fn test_return_from_fn() i32 {
|
||||
return 42;
|
||||
}
|
||||
|
||||
pub fn test_block_scope() {
|
||||
let x = {
|
||||
let inner = 10;
|
||||
inner + 5
|
||||
};
|
||||
assert_eq!(x, 15);
|
||||
}
|
||||
|
||||
pub fn test_match_literal() {
|
||||
let x = 2;
|
||||
let result;
|
||||
|
||||
match x {
|
||||
1 => { result = 10; }
|
||||
2 => { result = 20; }
|
||||
3 => { result = 30; }
|
||||
_ => panic!();
|
||||
}
|
||||
assert_eq!(result, 20);
|
||||
}
|
||||
|
||||
pub fn test_match_or_pattern() {
|
||||
let x = 1;
|
||||
let result i32;
|
||||
|
||||
match x {
|
||||
1 | 2 => { result = 100; }
|
||||
3 => { result = 200; }
|
||||
_ => panic!();
|
||||
}
|
||||
assert_eq!(result, 100);
|
||||
}
|
||||
|
||||
pub fn test_match_default() {
|
||||
let x = 99;
|
||||
let result;
|
||||
|
||||
match x {
|
||||
1 => { result = 10; }
|
||||
y => { result = y; }
|
||||
}
|
||||
assert_eq!(result, 99);
|
||||
}
|
||||
|
||||
pub fn test_for_with_pattern_destructure() {
|
||||
let pairs = [(1, "a"), (2, "b")];
|
||||
let mut keys = 0;
|
||||
|
||||
for [k, _] in pairs {
|
||||
keys += k;
|
||||
}
|
||||
assert_eq!(keys, 3);
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_var_decl();
|
||||
test_var_decl_with_init();
|
||||
test_if_statement();
|
||||
test_if_else_if();
|
||||
test_while_loop();
|
||||
test_for_loop();
|
||||
test_loop_stmt();
|
||||
test_break_continue();
|
||||
assert_eq!(test_return_from_fn(), 42);
|
||||
test_block_scope();
|
||||
test_match_literal();
|
||||
test_match_or_pattern();
|
||||
test_match_default();
|
||||
test_for_with_pattern_destructure();
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
pub module types_test;
|
||||
|
||||
pub fn test_integer_type() {
|
||||
let x i32 = 42;
|
||||
assert_eq!(x, 42);
|
||||
}
|
||||
|
||||
pub fn test_float_type() {
|
||||
let x f64 = 3.14;
|
||||
assert_eq!(x, 3.14);
|
||||
}
|
||||
|
||||
pub fn test_bool_type() {
|
||||
let x bool = true;
|
||||
assert_eq!(x, true);
|
||||
|
||||
let y bool = false;
|
||||
assert_eq!(y, false);
|
||||
}
|
||||
|
||||
pub fn test_string_type() {
|
||||
let s *str = "hello";
|
||||
assert_eq!(s, "hello");
|
||||
}
|
||||
|
||||
pub fn test_tuple_type() {
|
||||
let t [i32, *str] = (42, "answer");
|
||||
assert_eq!(t.0, 42);
|
||||
assert_eq!(t.1, "answer");
|
||||
}
|
||||
|
||||
pub fn test_ref_type() {
|
||||
let x i32 = 42;
|
||||
let r *i32 = &x;
|
||||
assert_eq!(*r, 42);
|
||||
}
|
||||
|
||||
pub fn test_mut_ref_type() {
|
||||
let mut x = 42;
|
||||
let r *mut i32 = &mut x;
|
||||
*r = 100;
|
||||
assert_eq!(x, 100);
|
||||
}
|
||||
|
||||
pub fn test_void_type() {}
|
||||
|
||||
fn add(a i32, b i32) i32 {
|
||||
a + b
|
||||
}
|
||||
|
||||
pub fn test_fn_return_type() {
|
||||
assert_eq!(add(3, 4), 7);
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_integer_type();
|
||||
test_float_type();
|
||||
test_bool_type();
|
||||
test_string_type();
|
||||
test_tuple_type();
|
||||
test_ref_type();
|
||||
test_mut_ref_type();
|
||||
test_void_type();
|
||||
test_fn_return_type();
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
pub module attribute_test;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Debuggable {
|
||||
value i32,
|
||||
}
|
||||
|
||||
pub fn test_derive_attribute() {
|
||||
let d = Debuggable { value: 42 };
|
||||
assert_eq!(d.value, 42);
|
||||
}
|
||||
|
||||
#[allow(unused_variables)]
|
||||
pub fn test_allow_attribute() {
|
||||
let x = 42;
|
||||
let y = "unused";
|
||||
assert_eq!(x, 42);
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_derive_attribute();
|
||||
test_allow_attribute();
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
pub module class_test;
|
||||
|
||||
pub class Animal<T> {
|
||||
pub name String;
|
||||
pub val T;
|
||||
|
||||
constructor() {
|
||||
self.name = "Rex".to_string();
|
||||
}
|
||||
|
||||
pub fn speak(*self) {
|
||||
println!("Unknown");
|
||||
}
|
||||
|
||||
pub fn test_speak(*self) {
|
||||
self.speak();
|
||||
}
|
||||
|
||||
pub fn static_method() {}
|
||||
}
|
||||
|
||||
pub class Mammal<T> : Animal<T> {
|
||||
constructor() {
|
||||
super = Super::new();
|
||||
}
|
||||
|
||||
pub fn args_test(*self, x i32, y *str) {}
|
||||
|
||||
pub fn returning<'a>(*self) *'a str {
|
||||
"Mammal"
|
||||
}
|
||||
}
|
||||
|
||||
pub class Dog : Mammal<i32> {
|
||||
constructor() {
|
||||
super = Super::new();
|
||||
}
|
||||
|
||||
pub override(Animal<i32>) fn speak(*self) {
|
||||
println!("Woof!");
|
||||
}
|
||||
|
||||
pub override fn returning(*self) *str {
|
||||
"Dog"
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
let dawg = Dog::new();
|
||||
|
||||
dawg.args_test(10, "hello");
|
||||
|
||||
dawg.test_speak();
|
||||
|
||||
println!("{}", dawg.returning());
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
pub module enum_test;
|
||||
|
||||
enum OptionInt {
|
||||
None,
|
||||
Some[i32],
|
||||
}
|
||||
|
||||
pub fn test_enum_named() {
|
||||
let x = OptionInt::None;
|
||||
match x {
|
||||
OptionInt::None => { assert_eq!(1, 1); }
|
||||
OptionInt::Some[_] => { assert_eq!(0, 1); }
|
||||
}
|
||||
}
|
||||
|
||||
pub fn test_enum_tuple() {
|
||||
let x = OptionInt::Some(42);
|
||||
match x {
|
||||
OptionInt::None => { assert_eq!(0, 1); }
|
||||
OptionInt::Some[v] => { assert_eq!(v, 42); }
|
||||
}
|
||||
}
|
||||
|
||||
enum Shape {
|
||||
Circle { radius i32 },
|
||||
Rect { w i32, h i32 },
|
||||
}
|
||||
|
||||
pub fn test_enum_struct() {
|
||||
let c = Shape::Circle { radius: 5 };
|
||||
match c {
|
||||
Shape::Circle { radius } => { assert_eq!(radius, 5); }
|
||||
Shape::Rect { .. } => { assert_eq!(0, 1); }
|
||||
}
|
||||
|
||||
let r = Shape::Rect { w: 3, h: 4 };
|
||||
match r {
|
||||
Shape::Circle { .. } => { assert_eq!(0, 1); }
|
||||
Shape::Rect { w, h } => { assert_eq!(w * h, 12); }
|
||||
}
|
||||
}
|
||||
|
||||
enum Color {
|
||||
Red,
|
||||
Green,
|
||||
Blue,
|
||||
}
|
||||
|
||||
pub fn test_enum_eq() {
|
||||
let c = Color::Red;
|
||||
match c {
|
||||
Color::Red => { assert_eq!(1, 1); }
|
||||
_ => { assert_eq!(0, 1); }
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_enum_named();
|
||||
test_enum_tuple();
|
||||
test_enum_struct();
|
||||
test_enum_eq();
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
pub module function_test;
|
||||
|
||||
fn greet() {
|
||||
let mut x = 1;
|
||||
x++;
|
||||
}
|
||||
|
||||
pub fn test_basic_function() {
|
||||
greet();
|
||||
}
|
||||
|
||||
fn add(a i32, b i32) i32 {
|
||||
a + b
|
||||
}
|
||||
|
||||
pub fn test_fn_params() {
|
||||
assert_eq!(add(2, 3), 5);
|
||||
}
|
||||
|
||||
pub fn test_fn_return() i32 {
|
||||
42
|
||||
}
|
||||
|
||||
pub fn test_fn_early_return() i32 {
|
||||
return 100;
|
||||
0
|
||||
}
|
||||
|
||||
pub fn test_fn_mut_param(mut x i32) i32 {
|
||||
x = x + 10;
|
||||
x
|
||||
}
|
||||
|
||||
pub fn test_method_call() {
|
||||
let s = "hello";
|
||||
assert_eq!(s.len(), 5);
|
||||
assert_eq!(s.to_uppercase(), "HELLO");
|
||||
}
|
||||
|
||||
fn triple(x i32) i32 {
|
||||
add(x, add(x, x))
|
||||
}
|
||||
|
||||
pub fn test_nested_fn_calls() {
|
||||
assert_eq!(triple(5), 15);
|
||||
}
|
||||
|
||||
fn factorial(n i32) i32 {
|
||||
if n <= 1 { 1 }
|
||||
else { n * factorial(n - 1) }
|
||||
}
|
||||
|
||||
pub fn test_recursive_fn() {
|
||||
assert_eq!(factorial(5), 120);
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_basic_function();
|
||||
test_fn_params();
|
||||
assert_eq!(test_fn_return(), 42);
|
||||
assert_eq!(test_fn_early_return(), 100);
|
||||
assert_eq!(test_fn_mut_param(5), 15);
|
||||
test_method_call();
|
||||
test_nested_fn_calls();
|
||||
test_recursive_fn();
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
pub module impl_test;
|
||||
|
||||
struct Vector2 {
|
||||
x i32,
|
||||
y i32,
|
||||
}
|
||||
|
||||
impl Vector2 {
|
||||
pub fn magnitude(*self) i32 {
|
||||
self.x * self.x + self.y * self.y
|
||||
}
|
||||
}
|
||||
|
||||
pub fn test_inherent_impl() {
|
||||
let v = Vector2 { x: 3, y: 4 };
|
||||
assert_eq!(v.magnitude(), 25);
|
||||
}
|
||||
|
||||
trait Display {
|
||||
fn display(*self) String;
|
||||
}
|
||||
|
||||
impl Display for Vector2 {
|
||||
fn display(*self) String {
|
||||
format!("({}, {})", self.x, self.y)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn test_trait_impl_block() {
|
||||
let v = Vector2 { x: 1, y: 2 };
|
||||
let s = v.display();
|
||||
assert_eq!(s.len() > 0, true);
|
||||
}
|
||||
|
||||
impl Vector2 {
|
||||
pub fn add(*self, other Vector2) Vector2 {
|
||||
Vector2 {
|
||||
x: self.x + other.x,
|
||||
y: self.y + other.y,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn test_multiple_impls() {
|
||||
let a = Vector2 { x: 1, y: 2 };
|
||||
let b = Vector2 { x: 3, y: 4 };
|
||||
let c = a.add(b);
|
||||
assert_eq!(c.x, 4);
|
||||
assert_eq!(c.y, 6);
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_inherent_impl();
|
||||
test_trait_impl_block();
|
||||
test_multiple_impls();
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
pub module struct_test;
|
||||
|
||||
struct Point {
|
||||
x i32,
|
||||
y i32,
|
||||
}
|
||||
|
||||
pub fn test_struct_create_access() {
|
||||
let p = Point { x: 10, y: 20 };
|
||||
assert_eq!(p.x, 10);
|
||||
assert_eq!(p.y, 20);
|
||||
}
|
||||
|
||||
pub fn test_struct_mut_field() {
|
||||
let mut p = Point { x: 1, y: 2 };
|
||||
p.x = 100;
|
||||
assert_eq!(p.x, 100);
|
||||
}
|
||||
|
||||
pub fn test_struct_destructure() {
|
||||
let p = Point { x: 3, y: 4 };
|
||||
let Point { x, y } = p;
|
||||
assert_eq!(x, 3);
|
||||
assert_eq!(y, 4);
|
||||
}
|
||||
|
||||
struct Line {
|
||||
start Point,
|
||||
end Point,
|
||||
}
|
||||
|
||||
pub fn test_struct_nested() {
|
||||
let l = Line {
|
||||
start: Point { x: 0, y: 0 },
|
||||
end: Point { x: 5, y: 10 },
|
||||
};
|
||||
assert_eq!(l.start.x, 0);
|
||||
assert_eq!(l.end.y, 10);
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_struct_create_access();
|
||||
test_struct_mut_field();
|
||||
test_struct_destructure();
|
||||
test_struct_nested();
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
pub module trait_test;
|
||||
|
||||
trait Speak {
|
||||
fn speak(*self) String;
|
||||
}
|
||||
|
||||
trait Greet : Speak {
|
||||
fn greet(*self) String;
|
||||
}
|
||||
|
||||
struct Dog {
|
||||
name String,
|
||||
}
|
||||
|
||||
impl Speak for Dog {
|
||||
fn speak(*self) String {
|
||||
"woof".to_string()
|
||||
}
|
||||
}
|
||||
|
||||
impl Greet for Dog {
|
||||
fn greet(*self) String {
|
||||
"hello".to_string()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn test_trait_impl() {
|
||||
let d = Dog { name: "Rex".to_string() };
|
||||
assert_eq!(d.speak(), "woof");
|
||||
}
|
||||
|
||||
pub fn test_trait_with_requirement() {
|
||||
let d = Dog { name: "Buddy".to_string() };
|
||||
assert_eq!(d.speak(), "woof");
|
||||
assert_eq!(d.greet(), "hello");
|
||||
}
|
||||
|
||||
pub fn run_tests() {
|
||||
test_trait_impl();
|
||||
test_trait_with_requirement();
|
||||
}
|
||||
+2
-16
@@ -1,19 +1,5 @@
|
||||
fn main() {
|
||||
fn Result<[], String> main() {
|
||||
println!("running common tests...");
|
||||
common::test_package();
|
||||
common::expr_test::run_tests();
|
||||
common::statement_test::run_tests();
|
||||
common::decl_test::run_tests();
|
||||
common::types_test::run_tests();
|
||||
|
||||
println!("running items tests...");
|
||||
items::function_test::run_tests();
|
||||
items::struct_test::run_tests();
|
||||
items::enum_test::run_tests();
|
||||
items::class_test::run_tests();
|
||||
items::trait_test::run_tests();
|
||||
items::impl_test::run_tests();
|
||||
items::attribute_test::run_tests();
|
||||
|
||||
println!("\x1b[32m\nAll tests passed!\x1b[0m");
|
||||
Ok(())
|
||||
}
|
||||
Reference in New Issue
Block a user