fix(minifier): avoid generating invalid spans (#15778)

This debug assertion failed
https://github.com/oxc-project/oxc/blob/ef4cc33b5cedde82d5b5f91355d7b39436bdbcd6/crates/oxc_span/src/span.rs#L169
when it's called by
https://github.com/oxc-project/oxc/blob/c023ba67e07283bad3a43ef9bcc0336c94aa42ae/crates/oxc_codegen/src/gen.rs#L2123
which was caused by
https://github.com/oxc-project/oxc/blob/102365da3dd02f5cdd444eaf04f8bbf91c814886/crates/oxc_minifier/src/peephole/fold_constants.rs#L445

This PR fixes these kinds of issues. This PR adds a test but does not fail even without the change. I'll fail once #15787 is done.

Author: sapphi-red

crates/oxc_minifier/src/peephole/fold_constants.rs

@@ -5,7 +5,7 @@ use oxc_ecmascript::{
     constant_evaluation::{ConstantEvaluation, ConstantValue, DetermineValueType, ValueType},
     side_effects::MayHaveSideEffects,
 };
-use oxc_span::GetSpan;
+use oxc_span::{GetSpan, SPAN};
 use oxc_syntax::operator::{BinaryOperator, LogicalOperator};
 
 use crate::ctx::Ctx;
@@ -361,7 +361,7 @@ impl<'a> PeepholeOptimizations {
         }
         debug_assert_eq!(e.operator, BinaryOperator::Addition);
 
-        if let Some(expr) = Self::try_fold_add_op(&mut e.left, &mut e.right, ctx) {
+        if let Some(expr) = Self::try_fold_add_op(&mut e.left, &mut e.right, e.span, ctx) {
             return Some(expr);
         }
 
@@ -373,15 +373,19 @@ impl<'a> PeepholeOptimizations {
                 left_binary_expr.right.get_side_free_string_value(ctx),
                 e.right.get_side_free_string_value(ctx),
             ) {
-                let span = Span::new(left_binary_expr.right.span().start, e.right.span().end);
+                let span = left_binary_expr
+                    .right
+                    .span()
+                    .merge_within(e.right.span(), e.span)
+                    .unwrap_or(SPAN);
                 let value = ctx.ast.atom_from_strs_array([&left_str, &right_str]);
                 let right = ctx.ast.expression_string_literal(span, value, None);
                 let left = left_binary_expr.left.take_in(ctx.ast);
                 return Some(ctx.ast.expression_binary(e.span, left, e.operator, right));
             }
 
             if let Some(new_right) =
-                Self::try_fold_add_op(&mut left_binary_expr.right, &mut e.right, ctx)
+                Self::try_fold_add_op(&mut left_binary_expr.right, &mut e.right, e.span, ctx)
             {
                 let left = left_binary_expr.left.take_in(ctx.ast);
                 return Some(ctx.ast.expression_binary(e.span, left, e.operator, new_right));
@@ -394,12 +398,13 @@ impl<'a> PeepholeOptimizations {
     fn try_fold_add_op(
         left_expr: &mut Expression<'a>,
         right_expr: &mut Expression<'a>,
+        parent_span: Span,
         ctx: &Ctx<'a, '_>,
     ) -> Option<Expression<'a>> {
         if let Expression::TemplateLiteral(left) = left_expr {
             // "`${a}b` + `x${y}`" => "`${a}bx${y}`"
             if let Expression::TemplateLiteral(right) = right_expr {
-                left.span = Span::new(left.span.start, right.span.end);
+                left.span = left.span.merge_within(right.span, parent_span).unwrap_or(SPAN);
                 let left_last_quasi =
                     left.quasis.last_mut().expect("template literal must have at least one quasi");
                 let right_first_quasi = right
@@ -426,7 +431,7 @@ impl<'a> PeepholeOptimizations {
 
             // "`${x}y` + 'z'" => "`${x}yz`"
             if let Some(right_str) = right_expr.get_side_free_string_value(ctx) {
-                left.span = Span::new(left.span.start, right_expr.span().end);
+                left.span = left.span.merge_within(right_expr.span(), parent_span).unwrap_or(SPAN);
                 let last_quasi =
                     left.quasis.last_mut().expect("template literal must have at least one quasi");
                 let new_raw = last_quasi.value.raw.to_string()
@@ -442,7 +447,7 @@ impl<'a> PeepholeOptimizations {
         } else if let Expression::TemplateLiteral(right) = right_expr {
             // "'x' + `y${z}`" => "`xy${z}`"
             if let Some(left_str) = left_expr.get_side_free_string_value(ctx) {
-                right.span = Span::new(left_expr.span().start, right.span.end);
+                right.span = right.span.merge_within(left_expr.span(), parent_span).unwrap_or(SPAN);
                 let first_quasi = right
                     .quasis
                     .first_mut()
@@ -509,7 +514,10 @@ impl<'a> PeepholeOptimizations {
             e.span,
             expr_to_move.take_in(ctx.ast),
             op,
-            ctx.value_to_expr(Span::new(left.right.span().start, e.right.span().end), v),
+            ctx.value_to_expr(
+                left.right.span().merge_within(e.right.span(), e.span).unwrap_or(SPAN),
+                v,
+            ),
         ))
     }
 

crates/oxc_minifier/src/peephole/minimize_logical_expression.rs

@@ -2,7 +2,7 @@ use oxc_allocator::TakeIn;
 use oxc_ast::ast::*;
 use oxc_compat::ESFeature;
 use oxc_semantic::ReferenceFlags;
-use oxc_span::{ContentEq, GetSpan};
+use oxc_span::{ContentEq, GetSpan, SPAN};
 
 use crate::ctx::Ctx;
 
@@ -55,7 +55,7 @@ impl<'a> PeepholeOptimizations {
         if left.operator != op {
             return None;
         }
-        let new_span = Span::new(left.right.span().start, expr.span.end);
+        let new_span = left.right.span().merge_within(expr.right.span(), expr.span).unwrap_or(SPAN);
         Self::try_compress_is_null_or_undefined_for_left_and_right(
             &mut left.right,
             &mut expr.right,

crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs

@@ -409,7 +409,7 @@ impl<'a> PeepholeOptimizations {
         let Some(new_expr) = Self::try_compress_is_object_and_not_null_for_left_and_right(
             &left.right,
             &e.right,
-            Span::new(left.right.span().start, e.span.end),
+            left.right.span().merge_within(e.right.span(), e.span).unwrap_or(SPAN),
             ctx,
             inversed,
         ) else {

crates/oxc_minifier/tests/peephole/oxc.rs

@@ -67,6 +67,16 @@ fn integration() {
         ",
         "v = KEY === 'delete' || KEY === 'has' ? function () { return 1 } : function () { return 2 }",
     );
+
+    test_unused(
+        "
+        const a = 'a';
+        window.foo
+        const b = `b`;
+        console.log(a + b);
+        ",
+        "window.foo, console.log('ab');",
+    );
 }
 
 #[test]