onedrop_hlsl/rewrite/

comma_paren.rs

//! Pass: lower C-style comma operator inside parenthesised expressions.
//!
//! HLSL's `(a, b, c)` is the comma operator — evaluate left-to-right, yield
//! the rightmost operand. The MD2 corpus uses this sparingly but it surfaces
//! in shapes like:
//!
//! ```hlsl
//! uv2 = uv + texsize.zx * (q3, q3);
//! ```
//!
//! (a redundant-but-valid double of `q3`; HLSL treats the parens as scalar
//! `q3` so the surrounding `texsize.zx * scalar` is well-typed). WGSL has
//! no comma operator — the parens parse `q3, q3` as two arguments and the
//! containing `*` rejects with `expected ')'; found ','`.
//!
//! The pass is purely token-driven: detect every `(` whose previous
//! non-whitespace token is *not* `Ident`, `Keyword`, `RParen`, `RBracket`
//! (those are call / index / cast contexts where commas separate
//! arguments, not operator operands), then scan for top-level commas
//! inside the matching pair and emit a single edit that strips every
//! token up to and including the final top-level comma.
//!
//! Skipping `Keyword` covers the `for(init; cond; step)` / `if(...)` /
//! `while(...)` / `do {...} while(...)` / `switch(...)` / `return (...)` /
//! cast contexts in one rule. The cost is missing the (very rare)
//! `return (a, b);` idiom; we judged that acceptable next to the
//! breakage potential of rewriting commas inside `for(int i = 0, j = 0;
//! ...)` init lists.
//!
//! Found in 17 warp + 2 comp presets on the 2 000-sample, all of which
//! presented as the `expected ')'; found ';'` cluster — once the comma
//! op is collapsed to its rightmost operand the surrounding expression
//! type-checks and naga validates.
//!
//! Idempotent: a second run sees no top-level commas inside any paren
//! expression and emits no edits.

use super::*;
use crate::lex::{Token, TokenKind, tokenize};

pub(crate) fn rewrite_comma_paren(src: &str) -> String {
    let Ok(tokens) = tokenize(src) else {
        return src.to_string();
    };
    let mut edits = Vec::new();
    collect_edits(&tokens, &mut edits);
    apply_edits(src, &mut edits)
}

/// For every paren-expression `(a, b, …, z)` (i.e. `(` not preceded by an
/// identifier / keyword / closing bracket), emit one edit removing
/// `a, b, …,` so only `z` remains inside the parens.
///
/// Nested paren-expressions with their own commas (`(a, (b, c), d)`) emit
/// only the *outermost* edit — the inner edit would overlap the outer
/// and get dropped by `apply_edits`'s overlap guard, leaving inner
/// rewrites half-done. Tracking absorbed-children per paren state keeps
/// the outer edit clean.
fn collect_edits(tokens: &[Token], edits: &mut Vec<TextEdit>) {
    let mut stack: Vec<ParenState> = Vec::new();

    for i in 0..tokens.len() {
        let t = &tokens[i];
        match &t.kind {
            TokenKind::LParen => {
                let is_call = i > 0 && is_call_like_prev(&tokens[i - 1].kind);
                stack.push(ParenState {
                    is_call,
                    open_end: t.span.end,
                    last_comma_end: None,
                    pending: Vec::new(),
                });
            }
            TokenKind::Comma => {
                if let Some(top) = stack.last_mut()
                    && !top.is_call
                {
                    top.last_comma_end = Some(t.span.end);
                }
            }
            TokenKind::RParen => {
                if let Some(top) = stack.pop() {
                    let own_edit = if !top.is_call && top.last_comma_end.is_some() {
                        Some(TextEdit {
                            start: top.open_end,
                            end: top.last_comma_end.unwrap(),
                            replacement: String::new(),
                        })
                    } else {
                        None
                    };
                    // If this paren emits its own edit, it subsumes every
                    // pending child edit (any nested comma-op gets
                    // collapsed alongside). Otherwise propagate the
                    // children up unchanged.
                    let to_publish: Vec<TextEdit> = if let Some(e) = own_edit {
                        vec![e]
                    } else {
                        top.pending
                    };
                    match stack.last_mut() {
                        Some(parent) => parent.pending.extend(to_publish),
                        None => edits.extend(to_publish),
                    }
                }
            }
            _ => {}
        }
    }
    // Anything left pending at top level (no enclosing paren) flushes here.
    while let Some(top) = stack.pop() {
        match stack.last_mut() {
            Some(parent) => parent.pending.extend(top.pending),
            None => edits.extend(top.pending),
        }
    }
}

struct ParenState {
    is_call: bool,
    open_end: u32,
    last_comma_end: Option<u32>,
    /// Edits emitted by paren-expressions strictly inside this one. If
    /// this paren ends up emitting its own outer edit they get dropped;
    /// otherwise they propagate up to the parent.
    pending: Vec<TextEdit>,
}

/// `(` is part of a call / index / cast context when preceded by one of
/// these tokens. Everything else is treated as a paren-expression where
/// inner top-level commas would be the C-style comma operator.
///
/// `Gt` is included because the HLSL grammar has no generic syntax, but
/// internally-emitted WGSL-shape source (`vec3<f32>(a, b, c)`) tokenises
/// the `>` as `Gt` immediately before the constructor `(`. Treating
/// `>(` as call-like keeps the comma-paren pass idempotent on previously
/// re-emitted source, at the negligible cost of skipping the (corpus-
/// absent) `a > (b, c)` operator-then-paren-expr shape.
fn is_call_like_prev(kind: &TokenKind) -> bool {
    matches!(
        kind,
        TokenKind::Ident
            | TokenKind::Keyword(_)
            | TokenKind::RParen
            | TokenKind::RBracket
            | TokenKind::Gt
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::translate_shader;

    fn rewrite(src: &str) -> String {
        rewrite_comma_paren(src)
    }

    #[test]
    fn paren_expr_comma_drops_left_operand() {
        let src = "shader_body { float2 uv2 = uv + texsize.zx*(q3,q3); }";
        let out = rewrite(src);
        // `(q3,q3)` collapses to `(q3)` (whitespace from the leading
        // operand may survive; downstream is whitespace-tolerant).
        assert!(!out.contains(','), "comma not removed: {out}");
        assert!(
            out.contains("q3)") && !out.contains("q3,"),
            "expected rightmost `q3` only, got: {out}"
        );
    }

    #[test]
    fn function_call_args_left_alone() {
        let src = "shader_body { float3 c = mix(a, b, 0.5); }";
        let out = rewrite(src);
        // mix() args must keep all commas — the `(` is preceded by `Ident`.
        assert_eq!(out, src);
    }

    #[test]
    fn vec_constructor_args_left_alone() {
        let src = "shader_body { float2 v = float2(q3, q3); }";
        let out = rewrite(src);
        // `float2(...)` is a call/constructor — leave the comma alone.
        assert_eq!(out, src);
    }

    #[test]
    fn for_init_with_comma_left_alone() {
        // `for(int i = 0, j = 0; …)` — the `(` is preceded by Keyword(For),
        // so we don't touch the comma in the init list.
        let src = "shader_body { for (int i = 0, j = 0; i < 4; i++) { } }";
        let out = rewrite(src);
        assert_eq!(out, src);
    }

    #[test]
    fn nested_paren_comma() {
        // `(a, (b, c), d)` — the outer `(a, …, d)` and the inner `(b, c)`
        // both have top-level commas. `apply_edits` drops overlapping
        // edits silently (the outer eats the inner), so the inner edit is
        // ignored and the outer leaves `(d)`.
        let src = "shader_body { float x = (a, (b, c), d); }";
        let out = rewrite(src);
        // Only the rightmost survives at the outer level.
        assert!(!out.contains(','), "stale comma: {out}");
        assert!(out.contains("d)"), "got: {out}");
        assert!(!out.contains("a,"), "outer LHS not stripped: {out}");
    }

    #[test]
    fn multiple_paren_exprs_independent() {
        let src = "shader_body { float x = (a, b) + (c, d, e); }";
        let out = rewrite(src);
        // Each paren-expression strips its own commas independently.
        assert!(!out.contains(','), "stale comma: {out}");
        assert!(out.contains("b)") && out.contains("e)"), "got: {out}");
        assert!(!out.contains("a,") && !out.contains("c,"), "got: {out}");
    }

    #[test]
    fn cast_followed_by_paren_left_alone() {
        // `(float)(x, y)` — the second `(` is preceded by `RParen`, so we
        // skip. (Rare in MD2; harmless to skip if it ever appeared.)
        let src = "shader_body { float v = (float)(x, y); }";
        let out = rewrite(src);
        assert_eq!(out, src);
    }

    #[test]
    fn translate_roundtrip_emits_wgsl_paren_singleton() {
        // End-to-end: the LuxXx warp shape compiles after the pass.
        let hlsl = r#"
shader_body {
    float q3 = 0.1;
    float2 uv = float2(0, 0);
    float4 texsize = float4(1, 1, 1, 1);
    float2 uv2 = uv + texsize.zx*(q3, q3);
}
"#;
        let wgsl = translate_shader(hlsl).expect("translates");
        // The comma is gone and only the rightmost `q3` remains in the
        // paren expression after the `*`.
        assert!(
            wgsl.contains("texsize.zx*( q3)") || wgsl.contains("texsize.zx*(q3)"),
            "expected collapsed comma op, got:\n{wgsl}"
        );
        assert!(!wgsl.contains("q3, q3"), "comma not removed:\n{wgsl}");
    }

    #[test]
    fn idempotent_on_single_operand_parens() {
        let src = "shader_body { float x = (a); }";
        let out = rewrite(src);
        assert_eq!(out, src);
        let out2 = rewrite(&out);
        assert_eq!(out, out2);
    }

    #[test]
    fn wgsl_shape_vec_constructor_left_alone() {
        // `vec3<f32>(1, 0, 0)` tokenises as `vec3 < f32 > ( 1 , 0 , 0 )`
        // under the HLSL grammar. The `(` is preceded by `Gt`; with the
        // `Gt`-skip rule the constructor's commas survive. Without it,
        // any re-parse of in-flight rewritten source would corrupt
        // `vec3<f32>(a, b, c)` into `vec3<f32>(c)`.
        let src = "shader_body { ret = vec3<f32>(1, 0, 0); }";
        let out = rewrite(src);
        assert_eq!(out, src);
    }

    #[test]
    fn comment_with_comma_inside_paren_is_not_a_comma_op() {
        // Comments are stripped at lex time, so a `,` inside a `//` line
        // doesn't survive into the token stream — the paren is treated as
        // a single-operand expression.
        let src = r#"shader_body { float x = (
    a // hello, world
); }"#;
        let out = rewrite(src);
        assert_eq!(out, src);
    }
}