feat(hydro_lang): introduce sliced! syntax for processing with anonymous ticks (#2256)

Author: shadaj

Cargo.lock

@@ -3,6 +3,7 @@
 # See "Adding new crates" and "Moving crates" addendum sections in `RELEASING.md`
 members = [
     "benches",
+    "copy_span",
     "dfir_lang",
     "dfir_macro",
     "dfir_rs",

Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "copy_span"
+publish = true
+version = "0.1.0"
+documentation = "https://docs.rs/copy_span/"
+description = "Macro emitting tokens with the span of another set of tokens."
+edition = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+
+[lints]
+workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0.95"
+syn = { version = "2", features = [ "parsing", "extra-traits" ] }

copy_span/Cargo.toml

@@ -0,0 +1,57 @@
+use syn::spanned::Spanned;
+
+struct CopySpanInput {
+    source: syn::Expr,
+    target: proc_macro2::TokenStream,
+}
+
+impl syn::parse::Parse for CopySpanInput {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let source: syn::Expr = input.parse()?;
+        input.parse::<syn::Token![,]>()?;
+        let target: proc_macro2::TokenStream = input.parse()?;
+        Ok(CopySpanInput { source, target })
+    }
+}
+
+fn recursively_set_span(token: &mut proc_macro2::TokenTree, span: proc_macro2::Span) {
+    match token {
+        proc_macro2::TokenTree::Group(group) => {
+            let new_stream = group
+                .stream()
+                .into_iter()
+                .map(|mut inner_token| {
+                    recursively_set_span(&mut inner_token, span);
+                    inner_token
+                })
+                .collect();
+
+            let mut new_group = proc_macro2::Group::new(group.delimiter(), new_stream);
+            new_group.set_span(span);
+            *group = new_group;
+        }
+        _ => {
+            token.set_span(span);
+        }
+    }
+}
+
+#[proc_macro]
+pub fn copy_span(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let CopySpanInput { source, target } = syn::parse_macro_input!(input as CopySpanInput);
+
+    let mut inner_source = source;
+    while let syn::Expr::Group(g) = inner_source {
+        inner_source = *g.expr;
+    }
+
+    let output = target
+        .into_iter()
+        .fold(proc_macro2::TokenStream::new(), |mut acc, mut token| {
+            recursively_set_span(&mut token, inner_source.span());
+            acc.extend(std::iter::once(token));
+            acc
+        });
+
+    proc_macro::TokenStream::from(output)
+}

copy_span/src/lib.rs

@@ -60,6 +60,7 @@ bincode = "1.3.1"
 clap = { version = "4.0", features = ["derive"], optional = true }
 hydro_deploy = { path = "../hydro_deploy/core", version = "^0.14.0", optional = true }
 hydro_deploy_integration = { path = "../hydro_deploy/hydro_deploy_integration", version = "^0.14.0", optional = true }
+copy_span = { path = "../copy_span", version = "^0.1.0" }
 dfir_rs = { path = "../dfir_rs", version = "^0.14.0", default-features = false, optional = true }
 dfir_lang = { path = "../dfir_lang", version = "^0.14.0", optional = true }
 futures = "0.3.0"

hydro_lang/Cargo.toml

@@ -17,17 +17,34 @@ pub struct Backtrace;
 #[derive(Clone)]
 pub struct Backtrace {
     skip_count: usize,
+    col_offset: usize, // whether this is from `sliced!` which requires an offset
     inner: RefCell<backtrace::Backtrace>,
     resolved: RefCell<Option<Vec<BacktraceElement>>>,
 }
 
+#[cfg(stageleft_runtime)]
+#[cfg(feature = "build")]
+#[doc(hidden)]
+pub fn __macro_get_backtrace(col_offset: usize) -> Backtrace {
+    let mut out = Backtrace::get_backtrace(1);
+    out.col_offset = col_offset;
+    out
+}
+
+#[cfg(not(feature = "build"))]
+#[doc(hidden)]
+pub fn __macro_get_backtrace(_col_offset: usize) -> Backtrace {
+    panic!();
+}
+
 impl Backtrace {
     #[cfg(feature = "build")]
     #[inline(never)]
     pub(crate) fn get_backtrace(skip_count: usize) -> Backtrace {
         let backtrace = backtrace::Backtrace::new_unresolved();
         Backtrace {
             skip_count,
+            col_offset: 0,
             inner: RefCell::new(backtrace),
             resolved: RefCell::new(None),
         }
@@ -50,7 +67,7 @@ impl Backtrace {
             .get_or_insert_with(|| {
                 let mut inner_borrow = self.inner.borrow_mut();
                 inner_borrow.resolve();
-                inner_borrow
+                let mut collected: Vec<_> = inner_borrow
                     .frames()
                     .iter()
                     .skip_while(|f| {
@@ -84,7 +101,17 @@ impl Backtrace {
                             addr: symbol.addr().map(|a| a as usize),
                         }
                     })
-                    .collect()
+                    .collect();
+
+                if self.col_offset > 0
+                    && let Some(first) = collected.first_mut()
+                {
+                    first.colno = first
+                        .colno
+                        .map(|c| c.saturating_sub(self.col_offset as u32));
+                }
+
+                collected
             })
             .clone()
     }

hydro_lang/src/compile/ir/backtrace.rs

@@ -3775,12 +3775,12 @@ mod test {
 
     #[test]
     fn hydro_node_size() {
-        assert_eq!(size_of::<HydroNode>(), 264);
+        assert_eq!(size_of::<HydroNode>(), 272);
     }
 
     #[test]
     fn hydro_root_size() {
-        assert_eq!(size_of::<HydroRoot>(), 160);
+        assert_eq!(size_of::<HydroRoot>(), 168);
     }
 
     #[test]

hydro_lang/src/compile/ir/mod.rs

@@ -6,7 +6,7 @@ expression: elements
     BacktraceElement {
         fn_name: "hydro_lang::compile::ir::backtrace::tests::test_backtrace",
         lineno: Some(
-            128,
+            155,
         ),
         colno: Some(
             25,
@@ -15,7 +15,7 @@ expression: elements
     BacktraceElement {
         fn_name: "hydro_lang::compile::ir::backtrace::tests::test_backtrace::{{closure}}",
         lineno: Some(
-            127,
+            154,
         ),
         colno: Some(
             24,

hydro_lang/src/compile/ir/snapshots/hydro_lang__compile__ir__backtrace__tests__backtrace.snap

@@ -24,6 +24,11 @@ pub mod runtime_support {
     pub mod resource_measurement;
 }
 
+#[doc(hidden)]
+pub mod macro_support {
+    pub use copy_span;
+}
+
 pub mod prelude {
     // taken from `tokio`
     //! A "prelude" for users of the `hydro_lang` crate.
@@ -44,6 +49,7 @@ pub mod prelude {
     pub use crate::live_collections::keyed_stream::KeyedStream;
     pub use crate::live_collections::optional::Optional;
     pub use crate::live_collections::singleton::Singleton;
+    pub use crate::live_collections::sliced::sliced;
     pub use crate::live_collections::stream::Stream;
     pub use crate::location::{Cluster, External, Location as _, Process, Tick};
     pub use crate::nondet::{NonDet, nondet};

hydro_lang/src/lib.rs

@@ -35,3 +35,5 @@ pub use singleton::Singleton;
 pub mod stream;
 #[doc(inline)]
 pub use stream::Stream;
+
+pub mod sliced;