Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 60 insertions, 0 deletions

diff --git a/third_party/rust/jsparagus-stencil/src/bytecode_offset.rs b/third_party/rust/jsparagus-stencil/src/bytecode_offset.rs
new file mode 100644
index 0000000000..3583ec6728
--- /dev/null
+++ b/third_party/rust/jsparagus-stencil/src/bytecode_offset.rs
@@ -0,0 +1,60 @@
+/// For tracking bytecode offsets in jumps
+#[derive(Clone, Copy, PartialEq, Debug)]
+#[must_use]
+pub struct BytecodeOffset {
+    pub offset: usize,
+}
+
+impl BytecodeOffset {
+    fn new(offset: usize) -> Self {
+        Self { offset }
+    }
+
+    /// diff_from is useful for finding the offset between two bytecodes. This is usually
+    /// used for jumps and jump_targets.
+    ///
+    /// For a forward jump, self will be a larger number, and start will be smaller
+    /// the output will be a positive number.  for a backward jump, the reverse
+    /// will be true, and the number will be negative. So it is important to use this api
+    /// consistently in both cases.
+    ///
+    /// Examples:
+    /// let offset_diff: BytecodeOffsetDiff = forward_jump_target_offset.diff_from(jump)
+    /// let offset_diff: BytecodeOffsetDiff = backward_jump_target_offset.diff_from(jump)
+    pub fn diff_from(self, start: BytecodeOffset) -> BytecodeOffsetDiff {
+        BytecodeOffsetDiff::new(self, start)
+    }
+}
+
+impl From<BytecodeOffset> for usize {
+    fn from(offset: BytecodeOffset) -> usize {
+        offset.offset
+    }
+}
+
+impl From<usize> for BytecodeOffset {
+    fn from(offset: usize) -> BytecodeOffset {
+        BytecodeOffset::new(offset)
+    }
+}
+
+pub struct BytecodeOffsetDiff {
+    diff: i32,
+}
+
+impl BytecodeOffsetDiff {
+    fn new(end: BytecodeOffset, start: BytecodeOffset) -> Self {
+        let diff = (end.offset as i128 - start.offset as i128) as i32;
+        Self { diff }
+    }
+
+    pub fn uninitialized() -> Self {
+        Self { diff: 0i32 }
+    }
+}
+
+impl From<BytecodeOffsetDiff> for i32 {
+    fn from(offset: BytecodeOffsetDiff) -> i32 {
+        offset.diff
+    }
+}