Chained if_then_else application change

lib/rust/parser/src/macros/built_in.rs

@@ -230,7 +230,7 @@ fn export_body<'s>(
 /// If-then-else macro definition.
 pub fn if_then_else<'s>() -> Definition<'s> {
     crate::macro_definition! {
-    ("if", everything(), "then", everything(), "else", everything()) if_body}
+    ("if", everything(), "then", everything(), "else", or(block(), many(not_block()))) if_body}
 }
 
 /// If-then macro definition.

lib/rust/parser/src/macros/expand.rs

@@ -162,6 +162,7 @@ impl<'s> Match<'s> {
             | Self::Nothing
             | Self::Identifier(_)
             | Self::Expected(_, _)
+            | Self::Block(_)
             | Self::NotBlock(_) => {}
             Self::Or(box OrMatch::First(item) | box OrMatch::Second(item)) =>
                 item.build_var_map(tree, validator),

lib/rust/parser/src/macros/pattern.rs

@@ -57,6 +57,10 @@ pub enum PatternData {
     Expected(String, Pattern),
     /// Named pattern. Mainly used for splicing the code in the macro definition body.
     Named(String, Pattern),
+    /// Consume a block.
+    Block,
+    /// Consume any item except a block.
+    NotBlock,
 }
 
 /// Constructor.
@@ -103,6 +107,16 @@ pub fn named(message: impl Into<String>, item: Pattern) -> Pattern {
     Pattern::new(PatternData::Named(message.into(), item), matches_empty_input)
 }
 
+/// Matches a block.
+pub fn block() -> Pattern {
+    Pattern::new(PatternData::Block, false)
+}
+
+/// Matches anything except a block.
+pub fn not_block() -> Pattern {
+    Pattern::new(PatternData::NotBlock, false)
+}
+
 impl Pattern {
     /// Repeat the current pattern multiple times.
     pub fn many(self) -> Self {
@@ -171,6 +185,7 @@ pub enum Match<'s> {
     Identifier(syntax::Item<'s>),
     Expected(String, Box<Match<'s>>),
     Named(String, Box<Match<'s>>),
+    Block(Vec<syntax::item::Line<'s>>),
     NotBlock(syntax::Item<'s>),
 }
 
@@ -208,6 +223,7 @@ impl<'s> Match<'s> {
         match self {
             Self::Nothing => (),
             Self::Identifier(item) | Self::NotBlock(item) => out.push(item),
+            Self::Block(lines) => out.push(syntax::Item::Block(lines)),
             Self::Everything(tokens) => out.extend(tokens),
             Self::Seq(fst, snd) => {
                 fst.get_tokens(out);
@@ -341,6 +357,23 @@ impl Pattern {
                         Err(input)
                     },
             },
+            PatternData::Block => match input.pop_front() {
+                None => Err(default()),
+                Some(syntax::Item::Block(lines)) =>
+                    Ok(MatchResult::new(Match::Block(lines), input)),
+                Some(t) => {
+                    input.push_front(t);
+                    Err(input)
+                }
+            },
+            PatternData::NotBlock => match input.pop_front() {
+                None => Err(default()),
+                Some(t @ syntax::Item::Block(_)) => {
+                    input.push_front(t);
+                    Err(input)
+                }
+                Some(t) => Ok(MatchResult::new(Match::NotBlock(t), input)),
+            },
         }
     }
 }

lib/rust/parser/src/macros/resolver.rs

@@ -123,18 +123,17 @@ impl<'a> SegmentMap<'a> {
 /// to learn more about the macro resolution steps.
 #[derive(Debug)]
 pub struct Resolver<'s> {
-    blocks:        Vec<Block>,
+    blocks:     Vec<Block>,
     /// The lines of all currently-open blocks. This is partitioned by `blocks`.
-    lines:         Vec<syntax::item::Line<'s>>,
+    lines:      Vec<syntax::item::Line<'s>>,
     /// All currently-open macros. These are partitioned into scopes by `blocks`.
-    macros:        Vec<PartiallyMatchedMacro<'s>>,
+    macros:     Vec<PartiallyMatchedMacro<'s>>,
     /// Segments of all currently-open macros. These are partitioned by `macros`.
-    segments:      Vec<MatchedSegment<'s>>,
+    segments:   Vec<MatchedSegment<'s>>,
     /// Items of all segments of all currently-open macros. These are partitioned by `segments`.
-    items:         Vec<syntax::Item<'s>>,
-    context:       Context,
-    precedence:    syntax::operator::Precedence<'s>,
-    start_segment: bool,
+    items:      Vec<syntax::Item<'s>>,
+    context:    Context,
+    precedence: syntax::operator::Precedence<'s>,
 }
 
 
@@ -144,14 +143,13 @@ impl<'s> Resolver<'s> {
     /// Create a new resolver, in statement context.
     pub fn new_statement() -> Self {
         Self {
-            context:       Context::Statement,
-            precedence:    syntax::operator::Precedence::new(),
-            blocks:        default(),
-            lines:         default(),
-            macros:        default(),
-            segments:      default(),
-            items:         default(),
-            start_segment: false,
+            context:    Context::Statement,
+            precedence: syntax::operator::Precedence::new(),
+            blocks:     default(),
+            lines:      default(),
+            macros:     default(),
+            segments:   default(),
+            items:      default(),
         }
     }
 
@@ -229,8 +227,6 @@ impl<'s> Resolver<'s> {
 
     /// Append a token to the state.
     fn push(&mut self, root_macro_map: &MacroMap, token: Token<'s>) {
-        let was_start_segment = self.start_segment;
-        self.start_segment = false;
         match token.variant {
             token::Variant::Newline(newline) => {
                 if !self.lines.is_empty() {
@@ -241,10 +237,6 @@ impl<'s> Resolver<'s> {
                 self.context = Context::Statement;
             }
             token::Variant::BlockStart(_) => {
-                if !was_start_segment {
-                    trace!("Finishing line!!!! {:?}", token);
-                    self.finish_current_line();
-                }
                 let macros_start = self.macros.len();
                 let outputs_start = self.lines.len();
                 let items = self.items.len();
@@ -274,7 +266,6 @@ impl<'s> Resolver<'s> {
                             let items_start = self.items.len();
                             self.segments.push(MatchedSegment { header, items_start });
                             self.context = Context::Expression;
-                            self.start_segment = true;
                             break;
                         }
                         Step::NormalToken(item) => {