refactor: fix span handling in sink_lets and remove_redundant_let_types

Transforms that create new statement wrappers need to preserve source spans
for the rewrite system to extract text during recovery.

Changes:
- Set stmt.span explicitly in transforms when wrapping locals
- Extend Splice for Stmt to include attributes from inner nodes
- Add fallback in rewrite_at_impl for macro-expanded code

Fixes sink_lets and remove_redundant_let_types on libxml2.

Author: oinoom

c2rust-refactor/src/rewrite/strategy/print.rs

@@ -252,7 +252,23 @@ impl Splice for Ty {
 
 impl Splice for Stmt {
     fn splice_span(&self) -> Span {
-        self.span
+        // Extend statement span to include attributes on the inner node.
+        //
+        // Transforms like sink_lets set stmt.span = local.span, but attributes are
+        // stored on the inner Local/Item/Expr, not the Stmt wrapper. The pretty-printer
+        // outputs attributes, but if stmt.span doesn't cover them, the rewrite system
+        // can't extract the complete source text.
+        //
+        // extend_span_attrs() expands the span backward to include attributes that
+        // appear before the node in source, checking syntax contexts to avoid crossing
+        // macro boundaries.
+        match &self.kind {
+            StmtKind::Local(local) => extend_span_attrs(self.span, &local.attrs),
+            StmtKind::Item(item) => extend_span_attrs(self.span, &item.attrs),
+            StmtKind::Expr(expr) | StmtKind::Semi(expr) => extend_span_attrs(self.span, &expr.attrs),
+            StmtKind::MacCall(mac) => extend_span_attrs(self.span, &mac.attrs),
+            StmtKind::Empty => self.span,
+        }
     }
 }
 
@@ -674,7 +690,29 @@ fn rewrite_at_impl<T>(old_span: Span, new: &T, mut rcx: RewriteCtxtRef) -> bool
 where
     T: PrintParse + RecoverChildren + Splice + MaybeGetNodeId,
 {
-    let printed = add_comments(new.to_string(), new, &rcx);
+    let mut printed = add_comments(new.to_string(), new, &rcx);
+
+    // Fallback: extract source snippet when pretty-printing produces empty output.
+    //
+    // When transforms move macro-expanded code (e.g., from #[derive]), the span may
+    // point to generated code with no source file location. Pretty-printing such nodes
+    // can produce empty output, which causes problems during the reparse/recovery phase.
+    //
+    // If the printed text is empty, try extracting the source directly using
+    // splice_span() (which includes attributes). If source is available, use that
+    // for reparsing instead of the empty pretty-printed text.
+    if printed.trim().is_empty() {
+        if let Ok(snippet) = rcx
+            .session()
+            .source_map()
+            .span_to_snippet(new.splice_span())
+        {
+            if !snippet.trim().is_empty() {
+                printed = snippet;
+            }
+        }
+    }
+
     let reparsed = T::parse(rcx.session(), &printed);
     let reparsed = reparsed.ast_deref();
 

c2rust-refactor/src/transform/vars.rs

@@ -192,7 +192,18 @@ impl Transform for SinkLets {
                                        Some(x) => x; return);
 
             let mut new_stmts = place_here.iter()
-                .map(|&id| mk().local_stmt(&locals[&id].local))
+                .map(|&id| {
+                    let local = &locals[&id].local;
+                    // Set the statement's span to match the local's span.
+                    //
+                    // By default, mk().local_stmt() creates a Stmt with DUMMY_SP. The rewrite system
+                    // uses stmt.span (via the Splice trait) to extract source text for recovery during
+                    // the print/reparse cycle. Without a valid span, source extraction fails.
+                    //
+                    // Setting stmt.span = local.span provides a valid source location. The Splice
+                    // implementation in print.rs will extend this to cover any attributes.
+                    mk().span(local.span).local_stmt(local)
+                })
                 .collect::<Vec<_>>();
             new_stmts.append(&mut b.stmts);
             b.stmts = new_stmts;
@@ -415,7 +426,21 @@ impl Transform for FoldLetAssign {
                     let local_mark = local_pos.remove(&hir_id).unwrap();
                     let mut l = local.clone();
                     l.kind = LocalKind::Init(init);
-                    curs.replace(|_| mk().local_stmt(l));
+
+                    // Preserve the original local's span when creating the combined statement.
+                    //
+                    // fold_let_assign transforms:
+                    //   let x;          <- original local
+                    //   x = expr;       <- assignment
+                    // into:
+                    //   let x = expr;   <- combined local
+                    //
+                    // The combined Local keeps l.span from the original declaration. Setting
+                    // stmt.span = l.span allows the rewrite system to extract source text using
+                    // the Splice trait. Without this, stmt.span would be DUMMY_SP and source
+                    // extraction would fail.
+                    let stmt_span = l.span;
+                    curs.replace(move |_| mk().span(stmt_span).local_stmt(l));
 
                     let here = curs.mark();
                     curs.seek(local_mark);
@@ -514,6 +539,7 @@ impl Transform for RemoveRedundantLetTypes {
         let pat = mcx.parse_stmts("let $pat:Pat : $ty:Ty = $init:Expr;");
         let repl = mcx.parse_stmts("let $pat = $init;");
         mut_visit_match_with(mcx, pat, krate, |ast, mcx| {
+            let orig_span = ast.get(0).map(|s| s.span);
             let e = mcx.bindings.get::<_, P<Expr>>("$init").unwrap();
             let e_ty = cx.adjusted_node_type(e.id);
             let e_ty = tcx.normalize_erasing_regions(ParamEnv::empty(), e_ty);
@@ -523,6 +549,14 @@ impl Transform for RemoveRedundantLetTypes {
             let t_ty = tcx.normalize_erasing_regions(ParamEnv::empty(), t_ty);
             if e_ty == t_ty {
                 *ast = repl.clone().subst(st, cx, &mcx.bindings);
+                // Preserve the original statement's span after replacement.
+                //
+                // The subst() call creates a new Stmt from the replacement pattern, which has
+                // a synthetic span from the pattern parse. Restoring the original span allows
+                // the rewrite system to extract source text via the Splice trait.
+                if let (Some(span), Some(first)) = (orig_span, ast.get_mut(0)) {
+                    first.span = span;
+                }
             }
         })
     }