windjammer 0.48.0

A simple language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//! Expression allocators for OwnershipTracker integration tests.

#![allow(dead_code)] // Helpers shared across analyzer tests; not every test uses every allocator

use windjammer::parser::ast::builders::*;
use windjammer::parser::ast::operators::BinaryOp;
use windjammer::parser::Expression;
use windjammer::test_utils::test_alloc_expr;

pub fn alloc_int(n: i64) -> &'static Expression<'static> {
    test_alloc_expr(expr_int(n))
}

pub fn alloc_var(name: impl Into<String>) -> &'static Expression<'static> {
    test_alloc_expr(expr_var(name))
}

pub fn alloc_field(obj: &'static Expression<'static>, field: &str) -> &'static Expression<'static> {
    test_alloc_expr(expr_field(obj, field))
}

pub fn alloc_index(
    obj: &'static Expression<'static>,
    idx: &'static Expression<'static>,
) -> &'static Expression<'static> {
    test_alloc_expr(expr_index(obj, idx))
}

pub fn alloc_method(
    obj: &'static Expression<'static>,
    method: &str,
    args: Vec<(Option<String>, &'static Expression<'static>)>,
) -> &'static Expression<'static> {
    test_alloc_expr(expr_method(obj, method, args))
}

pub fn alloc_unary(
    op: windjammer::parser::UnaryOp,
    operand: &'static Expression<'static>,
) -> &'static Expression<'static> {
    test_alloc_expr(expr_unary(op, operand))
}

pub fn alloc_binary(
    left: &'static Expression<'static>,
    op: BinaryOp,
    right: &'static Expression<'static>,
) -> &'static Expression<'static> {
    test_alloc_expr(expr_binary(op, left, right))
}

pub fn alloc_call(
    func: &'static Expression<'static>,
    args: Vec<(Option<String>, &'static Expression<'static>)>,
) -> &'static Expression<'static> {
    test_alloc_expr(expr_call(func, args))
}

pub fn alloc_struct(
    name: &str,
    fields: Vec<(String, &'static Expression<'static>)>,
) -> &'static Expression<'static> {
    test_alloc_expr(Expression::StructLiteral {
        name: name.to_string(),
        fields,
        location: None,
    })
}

pub fn alloc_array(elements: Vec<&'static Expression<'static>>) -> &'static Expression<'static> {
    test_alloc_expr(expr_array(elements))
}

pub fn alloc_tuple(elements: Vec<&'static Expression<'static>>) -> &'static Expression<'static> {
    test_alloc_expr(expr_tuple(elements))
}