Minifier: mangler is unreliable

[adamvleggett]

For WebGL 1 shaders, we still need texture2D, but it appears the mangler is renaming this keyword.

[arcman7]

For WGSL
It also:

• mangles variable names into reserved keywords such as "as"
• mangles "1e-6" into "1e -6" (same for 1e+6)
• possibly adds an extra comma to the last argument in a list of arguments to a function

But otherwise it works fine for me

[CodyJasonBennett]

I think that is largely fixed by re-implementing the minifier with the new AST (WGSL is still WIP there #20). It currently only uses the tokenizer and a few meticulously crafted heuristics for a mostly correct result, but not correct enough to be stable (basic whitespace collapse is fine though). WebGL1 is different since I need to add new keywords for minification but don't close the door for validation later.

[CodyJasonBennett]

The previous issue is resolved with v0.2.1 for WebGL1 keywords, but I'll reuse this issue for the mangler in general.

I would not suggest using that option until the minifier is rewritten to utilize the AST. With WebGPU and WGSL nearing living draft status, I can more comfortably make strides in their implementation.

Currently, I'm getting the GLSL side up to speed with #22, which will follow with WGSL.

[arcman7]

Nice! Please do let me know if there's any testing I can consequently help with in the near future.

[CodyJasonBennett]

The issues in #21 (comment) and #21 (comment) have since been fixed, and the minifier hardened in general.

Do note that the mangler is not yet deterministic until an AST is added for WGSL #20, and the minification process can then have perfect information over the program (right now it guesses with some mostly correct heuristics). You can already do this yourself for GLSL, which is well supported:

import { parse, GLSL_KEYWORDS, visit, generate } from 'shaderkit'

const program = parse(glsl)

// Optionally perform mangle
let mangleIndex = 0
const mangleMap = new Map()
visit(program, {
  Identifier(node) {
    // Skip built-ins
    if (GLSL_KEYWORDS.includes(node.name)) return

    // Perform mangle
    let renamed = mangleMap.get(node.name)
    while (!renamed || GLSL_KEYWORDS.includes(renamed)) {
      renamed = ''
      mangleIndex++

      let j = mangleIndex
      while (j > 0) {
        renamed = String.fromCharCode(97 + ((j - 1) % 26)) + renamed
        j = Math.floor(j / 26)
      }
    }

    // Cache and set mangled name
    mangleMap.set(node.name, renamed)
    node.name = renamed
  },
})

const output = generate(program, { target: 'GLSL' })

[CodyJasonBennett]

I just published an AST-driven mangler for GLSL in version 0.7.0 that performs the necessary static analysis to safely mangle variables and also handle preprocessor unfolding, which can be mangled as well. WGSL is not supported in the AST yet and still uses the old tokenizer-based minifier for mangling, which is unstable. In any case, a simple whitespace collapse always works.