Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 207 insertions, 0 deletions

diff --git a/third_party/rust/fluent-syntax/src/parser/pattern.rs b/third_party/rust/fluent-syntax/src/parser/pattern.rs
new file mode 100644
index 0000000000..516326d761
--- /dev/null
+++ b/third_party/rust/fluent-syntax/src/parser/pattern.rs
@@ -0,0 +1,207 @@
+use super::errors::{ErrorKind, ParserError};
+use super::{core::Parser, core::Result, slice::Slice};
+use crate::ast;
+
+#[derive(Debug, PartialEq)]
+enum TextElementTermination {
+    LineFeed,
+    CRLF,
+    PlaceableStart,
+    EOF,
+}
+
+// This enum tracks the placement of the text element in the pattern, which is needed for
+// dedentation logic.
+#[derive(Debug, PartialEq)]
+enum TextElementPosition {
+    InitialLineStart,
+    LineStart,
+    Continuation,
+}
+
+// This enum allows us to mark pointers in the source which will later become text elements
+// but without slicing them out of the source string. This makes the indentation adjustments
+// cheaper since they'll happen on the pointers, rather than extracted slices.
+#[derive(Debug)]
+enum PatternElementPlaceholders<S> {
+    Placeable(ast::Expression<S>),
+    // (start, end, indent, position)
+    TextElement(usize, usize, usize, TextElementPosition),
+}
+
+// This enum tracks whether the text element is blank or not.
+// This is important to identify text elements which should not be taken into account
+// when calculating common indent.
+#[derive(Debug, PartialEq)]
+enum TextElementType {
+    Blank,
+    NonBlank,
+}
+
+impl<'s, S> Parser<S>
+where
+    S: Slice<'s>,
+{
+    pub(super) fn get_pattern(&mut self) -> Result<Option<ast::Pattern<S>>> {
+        let mut elements = vec![];
+        let mut last_non_blank = None;
+        let mut common_indent = None;
+
+        self.skip_blank_inline();
+
+        let mut text_element_role = if self.skip_eol() {
+            self.skip_blank_block();
+            TextElementPosition::LineStart
+        } else {
+            TextElementPosition::InitialLineStart
+        };
+
+        while self.ptr < self.length {
+            if self.take_byte_if(b'{') {
+                if text_element_role == TextElementPosition::LineStart {
+                    common_indent = Some(0);
+                }
+                let exp = self.get_placeable()?;
+                last_non_blank = Some(elements.len());
+                elements.push(PatternElementPlaceholders::Placeable(exp));
+                text_element_role = TextElementPosition::Continuation;
+            } else {
+                let slice_start = self.ptr;
+                let mut indent = 0;
+                if text_element_role == TextElementPosition::LineStart {
+                    indent = self.skip_blank_inline();
+                    if let Some(b) = get_current_byte!(self) {
+                        if indent == 0 {
+                            if b != &b'\r' && b != &b'\n' {
+                                break;
+                            }
+                        } else if !Self::is_byte_pattern_continuation(*b) {
+                            self.ptr = slice_start;
+                            break;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+                let (start, end, text_element_type, termination_reason) = self.get_text_slice()?;
+                if start != end {
+                    if text_element_role == TextElementPosition::LineStart
+                        && text_element_type == TextElementType::NonBlank
+                    {
+                        if let Some(common) = common_indent {
+                            if indent < common {
+                                common_indent = Some(indent);
+                            }
+                        } else {
+                            common_indent = Some(indent);
+                        }
+                    }
+                    if text_element_role != TextElementPosition::LineStart
+                        || text_element_type == TextElementType::NonBlank
+                        || termination_reason == TextElementTermination::LineFeed
+                    {
+                        if text_element_type == TextElementType::NonBlank {
+                            last_non_blank = Some(elements.len());
+                        }
+                        elements.push(PatternElementPlaceholders::TextElement(
+                            slice_start,
+                            end,
+                            indent,
+                            text_element_role,
+                        ));
+                    }
+                }
+
+                text_element_role = match termination_reason {
+                    TextElementTermination::LineFeed => TextElementPosition::LineStart,
+                    TextElementTermination::CRLF => TextElementPosition::LineStart,
+                    TextElementTermination::PlaceableStart => TextElementPosition::Continuation,
+                    TextElementTermination::EOF => TextElementPosition::Continuation,
+                };
+            }
+        }
+
+        if let Some(last_non_blank) = last_non_blank {
+            let elements = elements
+                .into_iter()
+                .take(last_non_blank + 1)
+                .enumerate()
+                .map(|(i, elem)| match elem {
+                    PatternElementPlaceholders::Placeable(expression) => {
+                        ast::PatternElement::Placeable { expression }
+                    }
+                    PatternElementPlaceholders::TextElement(start, end, indent, role) => {
+                        let start = if role == TextElementPosition::LineStart {
+                            common_indent.map_or_else(
+                                || start + indent,
+                                |common_indent| start + std::cmp::min(indent, common_indent),
+                            )
+                        } else {
+                            start
+                        };
+                        let mut value = self.source.slice(start..end);
+                        if last_non_blank == i {
+                            value.trim();
+                        }
+                        ast::PatternElement::TextElement { value }
+                    }
+                })
+                .collect();
+            return Ok(Some(ast::Pattern { elements }));
+        }
+
+        Ok(None)
+    }
+
+    fn get_text_slice(
+        &mut self,
+    ) -> Result<(usize, usize, TextElementType, TextElementTermination)> {
+        let start_pos = self.ptr;
+        let mut text_element_type = TextElementType::Blank;
+
+        while let Some(b) = get_current_byte!(self) {
+            match b {
+                b' ' => self.ptr += 1,
+                b'\n' => {
+                    self.ptr += 1;
+                    return Ok((
+                        start_pos,
+                        self.ptr,
+                        text_element_type,
+                        TextElementTermination::LineFeed,
+                    ));
+                }
+                b'\r' if self.is_byte_at(b'\n', self.ptr + 1) => {
+                    self.ptr += 1;
+                    return Ok((
+                        start_pos,
+                        self.ptr - 1,
+                        text_element_type,
+                        TextElementTermination::CRLF,
+                    ));
+                }
+                b'{' => {
+                    return Ok((
+                        start_pos,
+                        self.ptr,
+                        text_element_type,
+                        TextElementTermination::PlaceableStart,
+                    ));
+                }
+                b'}' => {
+                    return error!(ErrorKind::UnbalancedClosingBrace, self.ptr);
+                }
+                _ => {
+                    text_element_type = TextElementType::NonBlank;
+                    self.ptr += 1
+                }
+            }
+        }
+        Ok((
+            start_pos,
+            self.ptr,
+            text_element_type,
+            TextElementTermination::EOF,
+        ))
+    }
+}