telltale-language 7.0.0

Shared choreography frontend for Telltale DSL parsing, projection, and macro code generation
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
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::collections::{HashMap, HashSet};

use super::super::role::parse_role_ref;
use super::super::statement::parse_message;
use super::super::types::Statement;
use super::super::ParseError;
use super::super::Rule;
use super::{
    extract_statement_annotations, next_required, parse_annotated_sender_ref, syntax_error,
};

/// Parse send statement: A -> B: Message(payload)
pub(crate) fn parse_send_stmt(
    pair: pest::iterators::Pair<Rule>,
    declared_roles: &HashSet<String>,
    input: &str,
) -> std::result::Result<Statement, ParseError> {
    let span = pair.as_span();
    let mut inner = pair.into_inner();

    let from_pair = next_required(&mut inner, span, input, "send is missing sender role")?;
    let (from, from_annotations) = match from_pair.as_rule() {
        Rule::annotated_sender_ref => parse_annotated_sender_ref(from_pair, declared_roles, input)?,
        Rule::role_ref => (
            parse_role_ref(from_pair, declared_roles, input)?,
            HashMap::new(),
        ),
        _ => {
            return Err(syntax_error(
                span,
                input,
                "send is missing sender role".to_string(),
            ))
        }
    };

    let to_pair = next_required(&mut inner, span, input, "send is missing receiver role")?;
    let to = parse_role_ref(to_pair, declared_roles, input)?;

    let message_pair = next_required(&mut inner, span, input, "send is missing message payload")?;
    let message = parse_message(message_pair, input)?;
    let annotations = extract_statement_annotations(&from_annotations);

    Ok(Statement::Send {
        from,
        to,
        message,
        annotations,
        from_annotations,
        to_annotations: HashMap::new(),
    })
}

/// Parse broadcast statement: A ->* : Message(payload)
pub(crate) fn parse_broadcast_stmt(
    pair: pest::iterators::Pair<Rule>,
    declared_roles: &HashSet<String>,
    input: &str,
) -> std::result::Result<Statement, ParseError> {
    let span = pair.as_span();
    let mut inner = pair.into_inner();

    let from_pair = next_required(&mut inner, span, input, "broadcast is missing sender role")?;
    let (from, from_annotations) = match from_pair.as_rule() {
        Rule::annotated_sender_ref => parse_annotated_sender_ref(from_pair, declared_roles, input)?,
        Rule::role_ref => (
            parse_role_ref(from_pair, declared_roles, input)?,
            HashMap::new(),
        ),
        _ => {
            return Err(syntax_error(
                span,
                input,
                "broadcast is missing sender role".to_string(),
            ))
        }
    };

    let message_pair = next_required(&mut inner, span, input, "broadcast is missing message")?;
    let message = parse_message(message_pair, input)?;
    let annotations = extract_statement_annotations(&from_annotations);

    Ok(Statement::Broadcast {
        from,
        message,
        annotations,
        from_annotations,
    })
}