| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use crate::parser_common::{ |
| compound_identifier, condition_value, many_until_eof, map_err, skip_ws, using_list, ws, |
| BindParserError, CompoundIdentifier, Include, NomSpan, Span, Value, |
| }; |
| use nom::{ |
| branch::alt, |
| bytes::complete::tag, |
| combinator::{opt, value}, |
| multi::{many1, separated_nonempty_list}, |
| sequence::{delimited, preceded, terminated, tuple}, |
| IResult, |
| }; |
| use std::convert::TryFrom; |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct Ast<'a> { |
| pub using: Vec<Include>, |
| pub statements: Vec<Statement<'a>>, |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum ConditionOp { |
| Equals, |
| NotEquals, |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct Condition<'a> { |
| pub span: Span<'a>, |
| pub lhs: CompoundIdentifier, |
| pub op: ConditionOp, |
| pub rhs: Value, |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum Statement<'a> { |
| ConditionStatement { |
| span: Span<'a>, |
| condition: Condition<'a>, |
| }, |
| Accept { |
| span: Span<'a>, |
| identifier: CompoundIdentifier, |
| values: Vec<Value>, |
| }, |
| If { |
| span: Span<'a>, |
| blocks: Vec<(Condition<'a>, Vec<Statement<'a>>)>, |
| else_block: Vec<Statement<'a>>, |
| }, |
| Abort { |
| span: Span<'a>, |
| }, |
| } |
| |
| impl<'a> Statement<'a> { |
| pub fn get_span(&'a self) -> &'a Span<'a> { |
| match self { |
| Statement::ConditionStatement { span, .. } => span, |
| Statement::Accept { span, .. } => span, |
| Statement::If { span, .. } => span, |
| Statement::Abort { span } => span, |
| } |
| } |
| } |
| |
| // TODO(fxbug.dev/35146): Improve error reporting here. |
| impl<'a> TryFrom<&'a str> for Ast<'a> { |
| type Error = BindParserError; |
| |
| fn try_from(input: &'a str) -> Result<Self, Self::Error> { |
| match program(NomSpan::new(input)) { |
| Ok((_, ast)) => Ok(ast), |
| Err(nom::Err::Error(e)) => Err(e), |
| Err(nom::Err::Failure(e)) => Err(e), |
| Err(nom::Err::Incomplete(_)) => { |
| unreachable!("Parser should never generate Incomplete errors") |
| } |
| } |
| } |
| } |
| |
| fn condition_op(input: NomSpan) -> IResult<NomSpan, ConditionOp, BindParserError> { |
| let equals = value(ConditionOp::Equals, tag("==")); |
| let not_equals = value(ConditionOp::NotEquals, tag("!=")); |
| map_err(alt((equals, not_equals)), BindParserError::ConditionOp)(input) |
| } |
| |
| fn condition(input: NomSpan) -> IResult<NomSpan, Condition, BindParserError> { |
| let from = skip_ws(input)?; |
| let (input, lhs) = ws(compound_identifier)(from)?; |
| let (input, op) = ws(condition_op)(input)?; |
| let (to, rhs) = ws(condition_value)(input)?; |
| |
| let span = Span::from_to(&from, &to); |
| Ok((to, Condition { span, lhs, op, rhs })) |
| } |
| |
| fn condition_statement(input: NomSpan) -> IResult<NomSpan, Statement, BindParserError> { |
| let from = skip_ws(input)?; |
| let terminator = ws(map_err(tag(";"), BindParserError::Semicolon)); |
| let (to, condition) = terminated(condition, terminator)(from)?; |
| |
| let span = Span::from_to(&from, &to); |
| Ok((to, Statement::ConditionStatement { span, condition })) |
| } |
| |
| fn keyword_if(input: NomSpan) -> IResult<NomSpan, NomSpan, BindParserError> { |
| ws(map_err(tag("if"), BindParserError::IfKeyword))(input) |
| } |
| |
| fn keyword_else(input: NomSpan) -> IResult<NomSpan, NomSpan, BindParserError> { |
| ws(map_err(tag("else"), BindParserError::ElseKeyword))(input) |
| } |
| |
| fn if_statement(input: NomSpan) -> IResult<NomSpan, Statement, BindParserError> { |
| let from = skip_ws(input)?; |
| |
| let if_block = tuple((preceded(keyword_if, condition), statement_block)); |
| let if_blocks = separated_nonempty_list(keyword_else, if_block); |
| |
| let else_block = preceded(keyword_else, statement_block); |
| |
| let (input, blocks) = if_blocks(from)?; |
| let (to, else_block) = else_block(input)?; |
| |
| let span = Span::from_to(&from, &to); |
| Ok((to, Statement::If { span, blocks, else_block })) |
| } |
| |
| fn statement_block(input: NomSpan) -> IResult<NomSpan, Vec<Statement>, BindParserError> { |
| let block_start = ws(map_err(tag("{"), BindParserError::IfBlockStart)); |
| let block_end = ws(map_err(tag("}"), BindParserError::IfBlockEnd)); |
| delimited(block_start, many1(ws(statement)), block_end)(input) |
| } |
| |
| fn keyword_accept(input: NomSpan) -> IResult<NomSpan, NomSpan, BindParserError> { |
| ws(map_err(tag("accept"), BindParserError::AcceptKeyword))(input) |
| } |
| |
| fn accept(input: NomSpan) -> IResult<NomSpan, Statement, BindParserError> { |
| let from = skip_ws(input)?; |
| |
| let list_start = ws(map_err(tag("{"), BindParserError::ListStart)); |
| let list_end = ws(map_err(tag("}"), BindParserError::ListEnd)); |
| let separator = || ws(map_err(tag(","), BindParserError::ListSeparator)); |
| |
| let values = separated_nonempty_list(separator(), ws(condition_value)); |
| // Lists may optionally be terminated by an additional trailing separator. |
| let values = terminated(values, opt(separator())); |
| let value_list = delimited(list_start, values, list_end); |
| |
| let (to, (identifier, values)) = |
| preceded(keyword_accept, tuple((ws(compound_identifier), value_list)))(from)?; |
| |
| let span = Span::from_to(&from, &to); |
| Ok((to, Statement::Accept { span, identifier, values })) |
| } |
| |
| fn abort(input: NomSpan) -> IResult<NomSpan, Statement, BindParserError> { |
| let from = skip_ws(input)?; |
| let keyword_abort = ws(map_err(tag("abort"), BindParserError::AbortKeyword)); |
| let terminator = ws(map_err(tag(";"), BindParserError::Semicolon)); |
| let (to, _) = terminated(keyword_abort, terminator)(from)?; |
| |
| let span = Span::from_to(&from, &to); |
| Ok((to, Statement::Abort { span })) |
| } |
| |
| fn statement(input: NomSpan) -> IResult<NomSpan, Statement, BindParserError> { |
| alt((condition_statement, if_statement, accept, abort))(input) |
| } |
| |
| fn program(input: NomSpan) -> IResult<NomSpan, Ast, BindParserError> { |
| let (input, using) = ws(using_list)(input)?; |
| let (input, statements) = many_until_eof(ws(statement))(input)?; |
| if statements.is_empty() { |
| return Err(nom::Err::Error(BindParserError::NoStatements(input.to_string()))); |
| } |
| Ok((input, Ast { using, statements })) |
| } |
| |
| #[cfg(test)] |
| mod test { |
| use super::*; |
| use crate::make_identifier; |
| use crate::parser_common::test::check_result; |
| |
| mod condition_ops { |
| use super::*; |
| |
| #[test] |
| fn equality() { |
| check_result(condition_op(NomSpan::new("==")), "", ConditionOp::Equals); |
| } |
| |
| #[test] |
| fn inequality() { |
| check_result(condition_op(NomSpan::new("!=")), "", ConditionOp::NotEquals); |
| } |
| |
| #[test] |
| fn invalid() { |
| assert_eq!( |
| condition_op(NomSpan::new(">=")), |
| Err(nom::Err::Error(BindParserError::ConditionOp(">=".to_string()))) |
| ); |
| } |
| |
| #[test] |
| fn empty() { |
| assert_eq!( |
| condition_op(NomSpan::new("")), |
| Err(nom::Err::Error(BindParserError::ConditionOp("".to_string()))) |
| ); |
| } |
| } |
| |
| mod conditions { |
| use super::*; |
| |
| #[test] |
| fn equality_condition() { |
| check_result( |
| condition(NomSpan::new("abc == true")), |
| "", |
| Condition { |
| span: Span { offset: 0, line: 1, fragment: "abc == true" }, |
| lhs: make_identifier!["abc"], |
| op: ConditionOp::Equals, |
| rhs: Value::BoolLiteral(true), |
| }, |
| ); |
| } |
| |
| #[test] |
| fn empty() { |
| assert_eq!( |
| condition(NomSpan::new("")), |
| Err(nom::Err::Error(BindParserError::Identifier("".to_string()))) |
| ); |
| } |
| |
| #[test] |
| fn span() { |
| // Span doesn't contain leading or trailing whitespace, and offset and line number |
| // are correct. |
| check_result( |
| condition(NomSpan::new(" \n\t\r\nabc \n\t\r\n== \n\t\r\ntrue \n\t\r\n")), |
| " \n\t\r\n", |
| Condition { |
| span: Span { offset: 5, line: 3, fragment: "abc \n\t\r\n== \n\t\r\ntrue" }, |
| lhs: make_identifier!["abc"], |
| op: ConditionOp::Equals, |
| rhs: Value::BoolLiteral(true), |
| }, |
| ); |
| } |
| } |
| |
| mod if_statements { |
| use super::*; |
| |
| #[test] |
| fn simple() { |
| check_result( |
| if_statement(NomSpan::new("if a == b { c == 1; } else { d == 2; }")), |
| "", |
| Statement::If { |
| span: Span { |
| offset: 0, |
| line: 1, |
| fragment: "if a == b { c == 1; } else { d == 2; }", |
| }, |
| blocks: vec![( |
| Condition { |
| span: Span { offset: 3, line: 1, fragment: "a == b" }, |
| lhs: make_identifier!["a"], |
| op: ConditionOp::Equals, |
| rhs: Value::Identifier(make_identifier!["b"]), |
| }, |
| vec![Statement::ConditionStatement { |
| span: Span { offset: 12, line: 1, fragment: "c == 1;" }, |
| condition: Condition { |
| span: Span { offset: 12, line: 1, fragment: "c == 1" }, |
| lhs: make_identifier!["c"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(1), |
| }, |
| }], |
| )], |
| else_block: vec![Statement::ConditionStatement { |
| span: Span { offset: 29, line: 1, fragment: "d == 2;" }, |
| condition: Condition { |
| span: Span { offset: 29, line: 1, fragment: "d == 2" }, |
| lhs: make_identifier!["d"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(2), |
| }, |
| }], |
| }, |
| ); |
| } |
| |
| #[test] |
| fn else_if() { |
| check_result( |
| if_statement(NomSpan::new( |
| "if a == b { c == 1; } else if e == 3 { d == 2; } else { f != 4; }", |
| )), |
| "", |
| Statement::If { |
| span: Span { |
| offset: 0, |
| line: 1, |
| fragment: |
| "if a == b { c == 1; } else if e == 3 { d == 2; } else { f != 4; }", |
| }, |
| blocks: vec![ |
| ( |
| Condition { |
| span: Span { offset: 3, line: 1, fragment: "a == b" }, |
| lhs: make_identifier!["a"], |
| op: ConditionOp::Equals, |
| rhs: Value::Identifier(make_identifier!["b"]), |
| }, |
| vec![Statement::ConditionStatement { |
| span: Span { offset: 12, line: 1, fragment: "c == 1;" }, |
| condition: Condition { |
| span: Span { offset: 12, line: 1, fragment: "c == 1" }, |
| lhs: make_identifier!["c"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(1), |
| }, |
| }], |
| ), |
| ( |
| Condition { |
| span: Span { offset: 30, line: 1, fragment: "e == 3" }, |
| lhs: make_identifier!["e"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(3), |
| }, |
| vec![Statement::ConditionStatement { |
| span: Span { offset: 39, line: 1, fragment: "d == 2;" }, |
| condition: Condition { |
| span: Span { offset: 39, line: 1, fragment: "d == 2" }, |
| lhs: make_identifier!["d"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(2), |
| }, |
| }], |
| ), |
| ], |
| else_block: vec![Statement::ConditionStatement { |
| span: Span { offset: 56, line: 1, fragment: "f != 4;" }, |
| condition: Condition { |
| span: Span { offset: 56, line: 1, fragment: "f != 4" }, |
| lhs: make_identifier!["f"], |
| op: ConditionOp::NotEquals, |
| rhs: Value::NumericLiteral(4), |
| }, |
| }], |
| }, |
| ); |
| } |
| |
| #[test] |
| fn nested() { |
| check_result( |
| if_statement(NomSpan::new( |
| "if a == 1 { if b == 2 { c != 3; } else { c == 3; } } else { d == 2; }", |
| )), |
| "", |
| Statement::If { |
| span: Span { |
| offset: 0, |
| line: 1, |
| fragment: |
| "if a == 1 { if b == 2 { c != 3; } else { c == 3; } } else { d == 2; }", |
| }, |
| blocks: vec![( |
| Condition { |
| span: Span { offset: 3, line: 1, fragment: "a == 1" }, |
| lhs: make_identifier!["a"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(1), |
| }, |
| vec![Statement::If { |
| span: Span { |
| offset: 12, |
| line: 1, |
| fragment: "if b == 2 { c != 3; } else { c == 3; }", |
| }, |
| blocks: vec![( |
| Condition { |
| span: Span { offset: 15, line: 1, fragment: "b == 2" }, |
| lhs: make_identifier!["b"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(2), |
| }, |
| vec![Statement::ConditionStatement { |
| span: Span { offset: 24, line: 1, fragment: "c != 3;" }, |
| condition: Condition { |
| span: Span { offset: 24, line: 1, fragment: "c != 3" }, |
| lhs: make_identifier!["c"], |
| op: ConditionOp::NotEquals, |
| rhs: Value::NumericLiteral(3), |
| }, |
| }], |
| )], |
| else_block: vec![Statement::ConditionStatement { |
| span: Span { offset: 41, line: 1, fragment: "c == 3;" }, |
| condition: Condition { |
| span: Span { offset: 41, line: 1, fragment: "c == 3" }, |
| lhs: make_identifier!["c"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(3), |
| }, |
| }], |
| }], |
| )], |
| else_block: vec![Statement::ConditionStatement { |
| span: Span { offset: 60, line: 1, fragment: "d == 2;" }, |
| condition: Condition { |
| span: Span { offset: 60, line: 1, fragment: "d == 2" }, |
| lhs: make_identifier!["d"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(2), |
| }, |
| }], |
| }, |
| ); |
| } |
| |
| #[test] |
| fn invalid() { |
| // Must have 'if' keyword. |
| assert_eq!( |
| if_statement(NomSpan::new("a == b { c == 1; }")), |
| Err(nom::Err::Error(BindParserError::IfKeyword("a == b { c == 1; }".to_string()))) |
| ); |
| |
| // Must have condition. |
| assert_eq!( |
| if_statement(NomSpan::new("if { c == 1; }")), |
| Err(nom::Err::Error(BindParserError::Identifier("{ c == 1; }".to_string()))) |
| ); |
| |
| // Must have else block. |
| assert_eq!( |
| if_statement(NomSpan::new("if a == b { c == 1; }")), |
| Err(nom::Err::Error(BindParserError::ElseKeyword("".to_string()))) |
| ); |
| assert_eq!( |
| if_statement(NomSpan::new("if a == b { c == 1; } else if e == 3 { d == 2; }")), |
| Err(nom::Err::Error(BindParserError::ElseKeyword("".to_string()))) |
| ); |
| |
| // Must delimit blocks with {}s. |
| assert_eq!( |
| if_statement(NomSpan::new("if a == b c == 1; }")), |
| Err(nom::Err::Error(BindParserError::IfBlockStart("c == 1; }".to_string()))) |
| ); |
| assert_eq!( |
| if_statement(NomSpan::new("if a == b { c == 1;")), |
| Err(nom::Err::Error(BindParserError::IfBlockEnd("".to_string()))) |
| ); |
| |
| // Blocks must not be empty. |
| // TODO(fxbug.dev/35146): Improve this error message, it currently reports a failure to parse |
| // an accept statement due to the way the combinator works for the statement parser. |
| assert!(if_statement(NomSpan::new("if a == b { } else { c == 1; }")).is_err()); |
| assert!(if_statement(NomSpan::new("if a == b { c == 1; } else { }")).is_err()); |
| } |
| |
| #[test] |
| fn empty() { |
| assert_eq!( |
| if_statement(NomSpan::new("")), |
| Err(nom::Err::Error(BindParserError::IfKeyword("".to_string()))) |
| ); |
| } |
| } |
| |
| mod accepts { |
| use super::*; |
| |
| #[test] |
| fn simple() { |
| check_result( |
| accept(NomSpan::new("accept a { 1 }")), |
| "", |
| Statement::Accept { |
| span: Span { offset: 0, line: 1, fragment: "accept a { 1 }" }, |
| identifier: make_identifier!["a"], |
| values: vec![Value::NumericLiteral(1)], |
| }, |
| ); |
| } |
| |
| #[test] |
| fn multiple_values() { |
| check_result( |
| accept(NomSpan::new("accept a { 1, 2 }")), |
| "", |
| Statement::Accept { |
| span: Span { offset: 0, line: 1, fragment: "accept a { 1, 2 }" }, |
| identifier: make_identifier!["a"], |
| values: vec![Value::NumericLiteral(1), Value::NumericLiteral(2)], |
| }, |
| ); |
| } |
| |
| #[test] |
| fn trailing_comma() { |
| check_result( |
| accept(NomSpan::new("accept a { 1, 2, }")), |
| "", |
| Statement::Accept { |
| span: Span { offset: 0, line: 1, fragment: "accept a { 1, 2, }" }, |
| identifier: make_identifier!["a"], |
| values: vec![Value::NumericLiteral(1), Value::NumericLiteral(2)], |
| }, |
| ); |
| } |
| |
| #[test] |
| fn invalid() { |
| // Must have accept keyword. |
| assert_eq!( |
| accept(NomSpan::new("a { 1 }")), |
| Err(nom::Err::Error(BindParserError::AcceptKeyword("a { 1 }".to_string()))) |
| ); |
| |
| // Must have identifier. |
| assert_eq!( |
| accept(NomSpan::new("accept { 1 }")), |
| Err(nom::Err::Error(BindParserError::Identifier("{ 1 }".to_string()))) |
| ); |
| |
| // Must have at least one value. |
| assert_eq!( |
| accept(NomSpan::new("accept a { }")), |
| Err(nom::Err::Error(BindParserError::ConditionValue("}".to_string()))) |
| ); |
| |
| // Must delimit blocks with {}s. |
| assert_eq!( |
| accept(NomSpan::new("accept a 1 }")), |
| Err(nom::Err::Error(BindParserError::ListStart("1 }".to_string()))) |
| ); |
| assert_eq!( |
| accept(NomSpan::new("accept a { 1")), |
| Err(nom::Err::Error(BindParserError::ListEnd("".to_string()))) |
| ); |
| } |
| |
| #[test] |
| fn empty() { |
| assert_eq!( |
| accept(NomSpan::new("")), |
| Err(nom::Err::Error(BindParserError::AcceptKeyword("".to_string()))) |
| ); |
| } |
| |
| #[test] |
| fn span() { |
| // Span doesn't contain leading or trailing whitespace, and line number is correct. |
| check_result( |
| condition(NomSpan::new(" \n\t\r\nabc \n\t\r\n== \n\t\r\ntrue \n\t\r\n")), |
| " \n\t\r\n", |
| Condition { |
| span: Span { offset: 5, line: 3, fragment: "abc \n\t\r\n== \n\t\r\ntrue" }, |
| lhs: make_identifier!["abc"], |
| op: ConditionOp::Equals, |
| rhs: Value::BoolLiteral(true), |
| }, |
| ); |
| } |
| } |
| |
| mod aborts { |
| use super::*; |
| |
| #[test] |
| fn simple() { |
| check_result( |
| abort(NomSpan::new("abort;")), |
| "", |
| Statement::Abort { span: Span { offset: 0, line: 1, fragment: "abort;" } }, |
| ); |
| } |
| |
| #[test] |
| fn invalid() { |
| // Must have abort keyword. |
| assert_eq!( |
| abort(NomSpan::new("a;")), |
| Err(nom::Err::Error(BindParserError::AbortKeyword("a;".to_string()))) |
| ); |
| assert_eq!( |
| abort(NomSpan::new(";")), |
| Err(nom::Err::Error(BindParserError::AbortKeyword(";".to_string()))) |
| ); |
| |
| // Must have semicolon. |
| assert_eq!( |
| abort(NomSpan::new("abort")), |
| Err(nom::Err::Error(BindParserError::Semicolon("".to_string()))) |
| ); |
| } |
| |
| #[test] |
| fn empty() { |
| assert_eq!( |
| abort(NomSpan::new("")), |
| Err(nom::Err::Error(BindParserError::AbortKeyword("".to_string()))) |
| ); |
| } |
| |
| #[test] |
| fn span() { |
| // Span doesn't contain leading or trailing whitespace, and line number is correct. |
| check_result( |
| accept(NomSpan::new(" \n\t\r\naccept a \n\t\r\n{ 1 } \n\t\r\n")), |
| " \n\t\r\n", |
| Statement::Accept { |
| span: Span { offset: 5, line: 3, fragment: "accept a \n\t\r\n{ 1 }" }, |
| identifier: make_identifier!["a"], |
| values: vec![Value::NumericLiteral(1)], |
| }, |
| ); |
| } |
| } |
| |
| mod programs { |
| use super::*; |
| |
| #[test] |
| fn simple() { |
| check_result( |
| program(NomSpan::new("using a; x == 1;")), |
| "", |
| Ast { |
| using: vec![Include { name: make_identifier!["a"], alias: None }], |
| statements: vec![Statement::ConditionStatement { |
| span: Span { offset: 9, line: 1, fragment: "x == 1;" }, |
| condition: Condition { |
| span: Span { offset: 9, line: 1, fragment: "x == 1" }, |
| lhs: make_identifier!["x"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(1), |
| }, |
| }], |
| }, |
| ); |
| } |
| |
| #[test] |
| fn empty() { |
| assert_eq!( |
| program(NomSpan::new("")), |
| Err(nom::Err::Error(BindParserError::NoStatements("".to_string()))) |
| ); |
| } |
| |
| #[test] |
| fn requires_statement() { |
| // Must have a statement. |
| assert_eq!( |
| program(NomSpan::new("using a;")), |
| Err(nom::Err::Error(BindParserError::NoStatements("".to_string()))) |
| ); |
| } |
| |
| #[test] |
| fn using_list_optional() { |
| check_result( |
| program(NomSpan::new("x == 1;")), |
| "", |
| Ast { |
| using: vec![], |
| statements: vec![Statement::ConditionStatement { |
| span: Span { offset: 0, line: 1, fragment: "x == 1;" }, |
| condition: Condition { |
| span: Span { offset: 0, line: 1, fragment: "x == 1" }, |
| lhs: make_identifier!["x"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(1), |
| }, |
| }], |
| }, |
| ); |
| } |
| |
| #[test] |
| fn requires_semicolons() { |
| // TODO(fxbug.dev/35146): Improve the error type that is returned here. |
| assert_eq!( |
| program(NomSpan::new("x == 1")), |
| Err(nom::Err::Error(BindParserError::AbortKeyword("x == 1".to_string()))) |
| ); |
| } |
| |
| #[test] |
| fn multiple_statements() { |
| check_result( |
| program(NomSpan::new( |
| "x == 1; accept y { true } abort; if z == 2 { a != 3; } else { a == 3; }", |
| )), |
| "", |
| Ast { |
| using: vec![], |
| statements: vec![ |
| Statement::ConditionStatement { |
| span: Span { offset: 0, line: 1, fragment: "x == 1;" }, |
| condition: Condition { |
| span: Span { offset: 0, line: 1, fragment: "x == 1" }, |
| lhs: make_identifier!["x"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(1), |
| }, |
| }, |
| Statement::Accept { |
| span: Span { offset: 8, line: 1, fragment: "accept y { true }" }, |
| identifier: make_identifier!["y"], |
| values: vec![Value::BoolLiteral(true)], |
| }, |
| Statement::Abort { span: Span { offset: 26, line: 1, fragment: "abort;" } }, |
| Statement::If { |
| span: Span { |
| offset: 33, |
| line: 1, |
| fragment: "if z == 2 { a != 3; } else { a == 3; }", |
| }, |
| blocks: vec![( |
| Condition { |
| span: Span { offset: 36, line: 1, fragment: "z == 2" }, |
| lhs: make_identifier!["z"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(2), |
| }, |
| vec![Statement::ConditionStatement { |
| span: Span { offset: 45, line: 1, fragment: "a != 3;" }, |
| condition: Condition { |
| span: Span { offset: 45, line: 1, fragment: "a != 3" }, |
| lhs: make_identifier!["a"], |
| op: ConditionOp::NotEquals, |
| rhs: Value::NumericLiteral(3), |
| }, |
| }], |
| )], |
| else_block: vec![Statement::ConditionStatement { |
| span: Span { offset: 62, line: 1, fragment: "a == 3;" }, |
| condition: Condition { |
| span: Span { offset: 62, line: 1, fragment: "a == 3" }, |
| lhs: make_identifier!["a"], |
| op: ConditionOp::Equals, |
| rhs: Value::NumericLiteral(3), |
| }, |
| }], |
| }, |
| ], |
| }, |
| ); |
| } |
| } |
| } |
