@galacean/engine-shader-compiler 2.0.0-alpha.32 → 2.0.0-alpha.33

package/dist/module.js

@@ -361,6 +361,9 @@ var ShaderCompilerUtils = /*#__PURE__*/ function() {
     };
     ShaderCompilerUtils.createGSError = function createGSError(message, errorName, source, location, file) {
         console.error(message);
+        var err = new Error(message);
+        err.name = errorName;
+        return err;
     };
     return ShaderCompilerUtils;
 }();
@@ -549,36 +552,46 @@ var ParserUtils = /*#__PURE__*/ function() {
         }).filter(Boolean);
     };
     /**
-   * Return the lexeme of `expr` when it is (transitively) a single bare identifier
-   * wrapped in primary/postfix expression nodes, e.g. `o` → "o". Returns null for
-   * compound expressions (`o.x`, `foo(..)`, `arr[0]`, …). Useful for callers that
-   * want to apply a substitution rule only at the root of an expression, never on
-   * swizzles or nested member access.
-   */ ParserUtils.extractDirectIdentLexeme = function extractDirectIdentLexeme(expr) {
-        var cur = expr;
-        while(cur){
-            if (_instanceof(cur, ASTNode.VariableIdentifier)) {
-                var child = cur.children[0];
-                return _instanceof(child, BaseToken) ? child.lexeme : null;
-            }
-            // `( expression )` form on PrimaryExpression — descend through the
-            // wrapped Expression so `(v)` resolves to `v`. All other compound
-            // forms (member access, function call, comma, …) bail out.
-            if (_instanceof(cur, ASTNode.PrimaryExpression) && cur.children.length === 3) {
-                cur = cur.children[1];
+   * Walk single-child precedence-chain wrappers down to a `VariableIdentifier`,
+   * returning the leaf node (or `undefined` for any compound expression).
+   *
+   * `allowParens` chooses between two callers' needs:
+   *   - `true` — descend through `( expression )` form, so `(v)` resolves to
+   *     `v`. Use when the caller substitutes at the expression root
+   *     (aliasing, renaming); user-written parens carry no extra meaning.
+   *   - `false` — any 3-child `PrimaryExpression` aborts; `(v)` stays
+   *     compound. Use when the caller treats the unwrapped node as a single
+   *     token (IO-struct arg drop, alias detection); user-written parens
+   *     must not collapse.
+   */ ParserUtils.unwrapBareIdentifier = function unwrapBareIdentifier(node, options) {
+        var cur = node;
+        while(true){
+            if (_instanceof(cur, ASTNode.VariableIdentifier)) return cur;
+            if (options.allowParens && _instanceof(cur, ASTNode.PrimaryExpression) && cur.children.length === 3) {
+                var inner = cur.children[1];
+                if (!_instanceof(inner, TreeNode)) return undefined;
+                cur = inner;
                 continue;
             }
-            // Any precedence-chain wrapper with a single child forwards through.
-            // Covers PostfixExpression / PrimaryExpression(len=1) / Assignment /
-            // Conditional / LogicalOr / … all the way down — including the verbose
-            // build's full chain and the release build's elision-flattened chain.
             if (_instanceof(cur, ASTNode.ExpressionAstNode) && cur.children.length === 1) {
-                cur = cur.children[0];
+                var child = cur.children[0];
+                if (!_instanceof(child, TreeNode)) return undefined;
+                cur = child;
                 continue;
             }
-            return null;
+            return undefined;
         }
-        return null;
+    };
+    /**
+   * Lexeme variant of `unwrapBareIdentifier({ allowParens: true })` for callers
+   * that already work with strings. Returns `null` for compound expressions.
+   */ ParserUtils.extractDirectIdentLexeme = function extractDirectIdentLexeme(expr) {
+        var ident = ParserUtils.unwrapBareIdentifier(expr, {
+            allowParens: true
+        });
+        if (!ident) return null;
+        var child = ident.children[0];
+        return _instanceof(child, BaseToken) ? child.lexeme : null;
     };
     ParserUtils.isTerminal = function isTerminal(sm) {
         return sm < NoneTerminal.START;
@@ -888,7 +901,7 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
     _inherits(Lexer, BaseLexer1);
     function Lexer(source, macroDefineList) {
         var _this;
-        _this = BaseLexer1.call(this, source) || this, _this.macroDefineList = macroDefineList, _this._needScanMacroConditionExpression = false, _this._inMacroDefineValue = false, _this._macroDefineExpectsNameToken = false, _this._macroDefineExpectsParamsToken = false, _this._macroDefineDirectiveStart = -1, _this._branchStack = [], _this._pendingBranchPushDefined = null;
+        _this = BaseLexer1.call(this, source) || this, _this.macroDefineList = macroDefineList, _this._needScanMacroConditionExpression = false, _this._inMacroDefineValue = false, _this._macroDefineExpectsNameToken = false, _this._macroDefineExpectsParamsToken = false, _this._currentMacroName = "", _this._currentMacroParamsLexeme = undefined, _this._currentMacroValueStart = -1, _this._branchStack = [], _this._pendingBranchPushDefined = null;
         return _this;
     }
     var _proto = Lexer.prototype;
@@ -1284,11 +1297,12 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
         var token = BaseToken.pool.get();
         var word = buffer.join("");
         if (word === "#define") {
-            // Mark the directive's start offset (the `#`) so the regex-based
-            // registrar can later slice out the full directive text from `_source`.
-            // Two paths share the same registrar — single source of truth.
-            this._macroDefineDirectiveStart = start.index;
-            if (this._defineHasValue()) {
+            var peek = this._peekMacroDefine();
+            if (peek && peek.isExpression) {
+                // AST path: the value will be tokenized by the lexer's `_inMacroDefineValue`
+                // state machine and re-parsed by the expression grammar. State machine
+                // fills `_currentMacroName` / `_currentMacroParamsLexeme` / `_currentMacroValueStart`
+                // as it walks the value; `_emitMacroDefineEnd` consumes them.
                 this._inMacroDefineValue = true;
                 // The next word is the macro name: force ID type even if a prior `#define`
                 // has already registered the name into `macroDefineList` (redefinition or
@@ -1296,10 +1310,13 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
                 this._macroDefineExpectsNameToken = true;
                 token.set(Keyword.MACRO_DEFINE, "#define", start);
             } else {
+                // Legacy path: opaque token sequence. Register directly from the peek
+                // result without re-walking the directive.
                 this._scanUtilBreakLine(buffer);
                 var lexeme = "\n" + buffer.join("") + "\n";
-                // Legacy path: register immediately by parsing the buffered directive.
-                this._registerMacroDefine(this._source.slice(this._macroDefineDirectiveStart, this._currentIndex));
+                if (peek) {
+                    this._registerMacroDefine(peek.name, peek.paramsLexeme, peek.valueStart, peek.valueEnd);
+                }
                 token.set(Keyword.MACRO_DEFINE_EXPRESSION, lexeme, start);
             }
         } else {
@@ -1316,66 +1333,151 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
         return c === "\n" || c === "\r";
     };
     /**
-   * Peek forward from `#define` and decide whether this directive should use the
-   * expression-AST path or the legacy opaque path.
+   * Walk a `#define` directive head once and produce everything both routing
+   * and registration need: name range, optional params range, value range,
+   * and whether the value parses as an `expression`.
+   *
+   * The replacement list is split three ways:
    *
-   * The AST path's only purpose is to enable the shader compiler's structural rewrites
-   * (varying flatten, struct-property reference tracking) on macro values that
-   * mention struct members. Every other shape — bare identifiers, numeric
-   * literals, type-alias keywords (`#define FxaaFloat2 vec2`), constructor
-   * calls, qualifier fragments, `#define COMMA ,` etc. — is correctly handled
-   * by the GLSL driver via textual substitution and needs no AST.
+   *  - **AST path** (`isExpression = true`): value parses as `expression`.
+   *    Covers identifiers, literals, parenthesized sub-expressions, operator
+   *    expressions, function calls, top-level comma lists (per C99 §6.10.3).
    *
-   * So the routing rule is positive and information-driven: **AST iff the
-   * replacement list contains a `.` member-access operator**. This is robust
-   * against new GLSL keywords / extensions and incidentally moves all simple
-   * constants and type aliases off the 18-layer expression precedence chain.
-   */ _proto._defineHasValue = function _defineHasValue() {
+   *  - **Legacy opaque path** (`isExpression = false`, no throw): the three
+   *    GLSL-ES-§3.4-legal-but-not-an-expression shapes with real-world use —
+   *      1. empty value                       e.g. `#define COMMON_INCLUDED`
+   *      2. single type/qualifier keyword     e.g. `#define FxaaFloat float`
+   *      3. type-qualifier list               e.g. `#define TEX_PARAM(s) mediump sampler2D s`
+   *
+   *    Note on X-macro support: the classical C X-macro pattern (a list
+   *    macro re-expanded with redefined `X(...)`) works fine — it uses
+   *    function-like macros + `\` line-continuation + `#undef`, all of
+   *    which Galacean supports. It does NOT require unbalanced parens.
+   *
+   *  - **Authoring error** (throws): every other shape that's not a valid
+   *    `expression`. Legal token sequences in theory but not used in real
+   *    GLSL — almost always author mistakes. We surface one uniform
+   *    diagnostic with the macro name and value text and let the user fix
+   *    their code instead of routing politely.
+   *
+   *    Unsupported shapes that throw (non-exhaustive — the predicate is
+   *    "the value doesn't reduce as `expression` and isn't one of the three
+   *    legacy shapes above"):
+   *      - leading bare punctuation       `,` `;` `:` `?` `)` `]`
+   *      - trailing `,` or `;`            e.g. `#define X a, b,`
+   *      - trailing binary / unary op     `+` `-` `*` `/` `%` `&` `|` `^`
+   *                                       `<` `>` `=` `!` `~`
+   *      - trailing ternary fragment      `?` or `:`
+   *      - unbalanced `[` / `]`           e.g. `#define X a[b`
+   *      - unbalanced `(` / `)`           e.g. `#define PAREN (`
+   *
+   * Returns `null` if the directive is malformed before the name. `cursor` is
+   * the position past the last non-newline char (caller advances from there).
+   */ _proto._peekMacroDefine = function _peekMacroDefine() {
         var src = this._source;
         var len = src.length;
-        // All position advancement goes through `_skipNonSemantic`, which honors
-        // line-continuation (`\` + newline) and skips comments. This is critical:
-        // `#define UV foo \\\n  .field` is one logical directive whose value
-        // contains `.field`, and `#define HP /* a.b */ highp` must not let the
-        // `.` inside the comment trigger AST routing.
         var i = Lexer._skipNonSemantic(src, this._currentIndex, len);
-        // Skip macro name
-        if (!(i < len && BaseLexer.isAlpha(src.charCodeAt(i)))) return false;
+        if (!(i < len && BaseLexer.isAlpha(src.charCodeAt(i)))) return null;
+        var nameStart = i;
         while(i < len && BaseLexer.isAlnum(src.charCodeAt(i)))i++;
-        i = Lexer._skipNonSemantic(src, i, len);
-        // Optional `(params)`: scan past a balanced pair on the same logical line
-        if (src.charCodeAt(i) === 40 /* '(' */ ) {
+        var name = src.slice(nameStart, i);
+        // Optional `(params)` glued to the name (function-like per C99 §6.10.3/10;
+        // whitespace before `(` makes it object-like — `(` becomes part of value).
+        var paramsLexeme;
+        if (i < len && src.charCodeAt(i) === 40 /* '(' */ ) {
+            var paramsStart = i;
             var depth = 1;
             i++;
             while(i < len && depth > 0){
                 i = Lexer._skipNonSemantic(src, i, len);
+                if (i >= len) break;
                 var c = src.charCodeAt(i);
-                if (c === 10 || c === 13) return false; // malformed: stay legacy
+                if (c === 10 || c === 13) {
+                    // Unbalanced before newline — treat as malformed function-like.
+                    return {
+                        name: name,
+                        paramsLexeme: undefined,
+                        valueStart: i,
+                        valueEnd: i,
+                        cursor: i,
+                        isExpression: false
+                    };
+                }
                 if (c === 40) depth++;
                 else if (c === 41 /* ')' */ ) depth--;
                 i++;
             }
+            paramsLexeme = src.slice(paramsStart, i);
         }
-        // Scan to end-of-directive looking for a `.` member-access operator.
-        // A `.` is member-access unless it's a decimal point inside a numeric
-        // literal — the latter has digits on both physical sides (`3.14`).
-        // Edge cases like `.5` go AST too (false positive, but AST path
-        // handles bare floats correctly).
+        // Walk the value once tracking what routing needs.
+        var valueStart = i;
+        var parenDepth = 0;
+        var bracketDepth = 0;
+        var firstStart = -1;
+        var firstEnd = -1;
+        var firstFollowedByParen = false;
+        var topLevelLast = -1;
         while(i < len){
-            i = Lexer._skipNonSemantic(src, i, len);
-            if (i >= len) break;
+            var skipped = Lexer._skipNonSemantic(src, i, len);
+            if (skipped !== i) {
+                i = skipped;
+                continue;
+            }
             var c1 = src.charCodeAt(i);
-            if (c1 === 10 || c1 === 13) break; // real newline ends directive
-            if (c1 === 46 /* '.' */ ) {
-                var prev = i > 0 ? src.charCodeAt(i - 1) : 0;
-                var next = i + 1 < len ? src.charCodeAt(i + 1) : 0;
-                var prevIsDigit = prev >= 48 && prev <= 57;
-                var nextIsDigit = next >= 48 && next <= 57;
-                if (!(prevIsDigit && nextIsDigit)) return true;
+            if (c1 === 10 || c1 === 13) break;
+            if (firstStart === -1) {
+                firstStart = i;
+                if (BaseLexer.isAlpha(c1)) {
+                    while(i < len && BaseLexer.isAlnum(src.charCodeAt(i)))i++;
+                    firstEnd = i;
+                    var after = Lexer._skipNonSemantic(src, i, len);
+                    firstFollowedByParen = after < len && src.charCodeAt(after) === 40;
+                    topLevelLast = firstEnd - 1;
+                    continue;
+                }
             }
+            if (c1 === 40) parenDepth++;
+            else if (c1 === 41) parenDepth--;
+            else if (c1 === 91 /* [ */ ) bracketDepth++;
+            else if (c1 === 93 /* ] */ ) bracketDepth--;
+            if (parenDepth === 0 && bracketDepth === 0) topLevelLast = i;
             i++;
         }
-        return false;
+        var result = {
+            name: name,
+            paramsLexeme: paramsLexeme,
+            valueStart: valueStart,
+            valueEnd: i,
+            cursor: i,
+            isExpression: false
+        };
+        // Real-world legacy shapes:
+        //   1. empty value, 2. single type/qualifier kw, 3. type-qualifier list.
+        if (firstStart === -1) return result;
+        if (firstEnd !== -1 && !firstFollowedByParen && Lexer._isNonExpressionLeadingKeyword(src.slice(firstStart, firstEnd))) {
+            return result;
+        }
+        // Authoring errors. Anything that's neither a legal `expression` nor one
+        // of the three legacy shapes above gets a single uniform diagnostic —
+        // the user sees the macro name and the value text, that's enough to
+        // locate and fix. We don't categorize further; the rule for users is
+        // simply "value must be a valid GLSL expression".
+        //
+        // Legal expression starts: alnum (identifier / literal), `(` (group),
+        // `.` (GLSL ES §4.1.4 leading-dot float literal like `.5`), `-`/`+`/`!`/`~`
+        // (unary). Legal expression ends: alnum (identifier / literal), `)` (group
+        // close), `]` (array-index close). Everything else at the head or
+        // top-level tail is an authoring error.
+        var head = src.charCodeAt(firstStart);
+        var tail = topLevelLast >= 0 ? src.charCodeAt(topLevelLast) : 0;
+        var headIllegal = !BaseLexer.isAlnum(head) && head !== 40 /* ( */  && head !== 46 /* . */  && head !== 45 /* - */  && head !== 43 /* + */  && head !== 33 /* ! */  && head !== 126; /* ~ */ 
+        var tailIllegal = !BaseLexer.isAlnum(tail) && tail !== 41 /* ) */  && tail !== 93; /* ] */ 
+        if (parenDepth !== 0 || bracketDepth !== 0 || headIllegal || tailIllegal) {
+            var valueText = src.slice(firstStart, i).replace(/\s+/g, " ").trim();
+            this.throwError(this.getShaderPosition(0), "#define " + name + ': invalid replacement list — not a valid GLSL expression ("' + valueText + '")');
+        }
+        result.isExpression = true;
+        return result;
     };
     /** Consuming wrapper around `_skipNonSemantic` operating on the lexer's
    *  current position. Used by the `#define`-value scan state machine. Goes
@@ -1419,11 +1521,16 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
             this.advance(1);
         }
         var token = BaseToken.pool.get();
-        token.set(Keyword.MACRO_DEFINE_PARAMS, buffer.join(""), start);
+        var lexeme = buffer.join("");
+        this._currentMacroParamsLexeme = lexeme;
+        // Value starts after the `)` we just consumed.
+        this._currentMacroValueStart = this._currentIndex;
+        token.set(Keyword.MACRO_DEFINE_PARAMS, lexeme, start);
         return token;
     };
     /** Emit `MACRO_DEFINE_END` at the end of a `#define` value, consuming the newline. */ _proto._emitMacroDefineEnd = function _emitMacroDefineEnd() {
         var start = this.getShaderPosition();
+        var valueEnd = this._currentIndex;
         var source = this._source;
         if (this._currentIndex < source.length) {
             var c = source.charCodeAt(this._currentIndex);
@@ -1433,37 +1540,29 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
                 this.advance(1);
             }
         }
-        // Register the directive into macroDefineList — single source of truth.
-        this._registerMacroDefine(this._source.slice(this._macroDefineDirectiveStart, this._currentIndex));
+        this._registerMacroDefine(this._currentMacroName, this._currentMacroParamsLexeme, this._currentMacroValueStart, valueEnd);
         this._inMacroDefineValue = false;
         var token = BaseToken.pool.get();
         token.set(Keyword.MACRO_DEFINE_END, "\n", start);
         return token;
     };
-    // Parse a `#define <name>[(params)] [value]` directive (already lexed to
-    // its newline) and register it. Both AST and legacy paths funnel through
-    // here — single source of truth, no drift between two analyzers.
-    _proto._registerMacroDefine = function _registerMacroDefine(directive) {
-        // Fold line-continuations before matching: per C/GLSL preprocessor rules
-        // `\` immediately before a newline removes both characters and stitches
-        // the next physical line onto this one. The regex's value group rejects
-        // newlines, so without folding any multi-line directive (`#define X a \\\n + b`)
-        // would NO MATCH and registration would silently fail.
-        var folded = directive.replace(Lexer._lineContinuationReg, "");
-        var m = Lexer._defineDirectiveReg.exec(folded);
-        if (!m) return;
-        var name = m[1];
-        var paramsStr = m[3];
-        var valueRaw = m[4];
-        var params = paramsStr ? paramsStr.split(",").map(function(p) {
+    // Register a `#define` directive. Both AST and legacy paths funnel through
+    // here using ranges already extracted by `_peekMacroDefine` / the value
+    // state machine — no re-parsing the directive text.
+    _proto._registerMacroDefine = function _registerMacroDefine(name, paramsLexeme, valueStart, valueEnd) {
+        var params = paramsLexeme ? paramsLexeme.slice(1, -1) // strip enclosing `(` `)`
+        .split(",").map(function(p) {
             return p.trim();
         }).filter(Boolean) : [];
-        var refMatch = valueRaw ? Lexer._referenceReg.exec(valueRaw.trim()) : null;
+        // Dedup key: normalized value text (same lexical view the token-stream
+        // path sees — comments stripped, whitespace collapsed). Two `#define`s
+        // with the same name but different value text produce different keys,
+        // so disjoint-branch entries stay separate.
+        var dedupKey = (paramsLexeme != null ? paramsLexeme : "") + "=" + Lexer._normalizeValueText(this._source, valueStart, valueEnd);
         var info = {
-            isFunction: m[2] !== undefined,
-            name: name,
+            isFunction: paramsLexeme !== undefined,
             params: params,
-            referenceName: refMatch ? refMatch[1] : "",
+            dedupKey: dedupKey,
             branch: this._branchStack.length === 0 ? EMPTY_BRANCH : this._branchStack.slice()
         };
         var arr = this.macroDefineList[name];
@@ -1473,14 +1572,11 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
             ];
             return;
         }
-        // Skip duplicates from re-includes / re-definitions in the same `#ifdef`
-        // branch. Different branches → different entries (the call-site filter
-        // picks the visible one); same branch + same shape → drop.
+        // Same key + same branch → duplicate (re-include). Different branches stay
+        // separate so the visibility filter picks the right entry at each call site.
         for(var i = 0, n = arr.length; i < n; i++){
             var e = arr[i];
-            if (e.isFunction === info.isFunction && e.referenceName === info.referenceName && e.params.length === info.params.length && e.params.every(function(p, idx) {
-                return p === info.params[idx];
-            }) && Lexer.sameBranch(e.branch, info.branch)) return;
+            if (e.dedupKey === dedupKey && Lexer.sameBranch(e.branch, info.branch)) return;
         }
         arr.push(info);
     };
@@ -1510,6 +1606,8 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
             // Bypass MACRO_CALL classification for this one word. Used for the name of
             // a `#define` directive so redefining a known macro still yields a declarer ID.
             this._macroDefineExpectsNameToken = false;
+            this._currentMacroName = word;
+            this._currentMacroParamsLexeme = undefined;
             // C99 §6.10.3/3: the macro is function-like only when `(` appears *immediately*
             // after the name (no intervening whitespace). `#define FOO (1+2)` is
             // object-like with value `(1+2)`, not a function-like macro `FOO()` with
@@ -1517,6 +1615,10 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
             // on the next `scanToken`, so a space-separated `(` stays part of the value.
             if (this._inMacroDefineValue) {
                 this._macroDefineExpectsParamsToken = this.getCurChar() === "(";
+                // For object-like macros, the value begins where the cursor is now
+                // (after the name, before whitespace skipping). Function-like macros
+                // overwrite this in `_scanMacroDefineParams` after capturing `(...)`.
+                this._currentMacroValueStart = this._currentIndex;
             }
             token.set(ETokenType.ID, word, start);
         } else if (this._isVisibleMacro(word)) {
@@ -1656,6 +1758,12 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
         }
         return true;
     };
+    /** GLSL type / qualifier keywords that aren't expression starters when standing alone.
+   *  `true` / `false` are excluded — they're `primary_expression` literals.
+   *  `#`-prefixed entries are excluded — they're preprocessor directive names. */ Lexer._isNonExpressionLeadingKeyword = function _isNonExpressionLeadingKeyword(lexeme) {
+        var kw = Lexer._lexemeTable[lexeme];
+        return kw !== undefined && kw !== Keyword.True && kw !== Keyword.False && !lexeme.startsWith("#");
+    };
     /**
    * If `i` points at a `\` immediately followed by a newline (`\n`, `\r`, or
    * `\r\n`), return the index just past the pair (a single atom in the C/GLSL
@@ -1663,8 +1771,7 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
    * source of truth for line-continuation detection — callers along the
    * directive-scanning path (`_skipNonSemantic`, `_scanUtilBreakLine`,
    * `_scanMacroDefineParams`) all delegate here so the rule stays in one
-   * place. The string-level `_lineContinuationReg` covers the regex path
-   * used by `_registerMacroDefine` for one-shot folding.
+   * place.
    */ Lexer._skipLineContinuation = function _skipLineContinuation(src, i, len) {
         if (src.charCodeAt(i) !== 92 /* '\\' */  || i + 1 >= len) return i;
         var n = src.charCodeAt(i + 1);
@@ -1707,6 +1814,34 @@ var GSErrorName = /*#__PURE__*/ function(GSErrorName) {
         }
         return i;
     };
+    /** Render a `[start, end)` value range as space-separated significant chars,
+   *  using the same comment / line-continuation rules `_skipNonSemantic`
+   *  applies on the token-stream path. Used as the dedup key body. */ Lexer._normalizeValueText = function _normalizeValueText(src, start, end) {
+        var out = "";
+        var i = start;
+        var pendingSpace = false;
+        while(i < end){
+            var skipped = Lexer._skipNonSemantic(src, i, end);
+            if (skipped !== i) {
+                pendingSpace = out.length > 0;
+                i = skipped;
+                continue;
+            }
+            var c = src.charCodeAt(i);
+            if (c === 32 || c === 9) {
+                pendingSpace = out.length > 0;
+                i++;
+                continue;
+            }
+            if (pendingSpace) {
+                out += " ";
+                pendingSpace = false;
+            }
+            out += src[i];
+            i++;
+        }
+        return out;
+    };
     return Lexer;
 }(BaseLexer);
 Lexer._lexemeTable = {
@@ -1783,12 +1918,6 @@ Lexer._lexemeTable = {
     "#endif": Keyword.MACRO_ENDIF,
     "#undef": Keyword.MACRO_UNDEF
 };
-// Single source of truth for `#define` parsing — fed from both AST and legacy paths.
-Lexer._defineDirectiveReg = /^\s*#define\s+(\w+)[ ]*(\(([^)]*)\))?(?:[ \t]+([^\n\r]*?))?\s*$/;
-// Bare identifier or call form only — mixed-operator values reject.
-Lexer._referenceReg = /^([a-zA-Z_]\w*)(?:\s*\(.*\))?$/;
-// C preprocessor line continuation.
-Lexer._lineContinuationReg = /\\(?:\r\n|\n|\r)/g;
 // Synthetic `__if_<n>` per `#if` — polarity flip makes `#else` mutually exclusive in `isVisibleFrom`.
 Lexer._ifCounter = 0;
 
@@ -3991,34 +4120,13 @@ var TreeNode = /*#__PURE__*/ function() {
             var child = this.children[0];
             var referenceGlobalSymbolNames = this.referenceGlobalSymbolNames;
             var symbols = this._symbols;
-            var lookupSymbol = SemanticAnalyzer._lookupSymbol;
-            var needFindNames;
-            // FXAA-style cross-arm shadowing: same name is a macro in one
-            // preprocessor arm and a variable in the mutually-exclusive arm.
-            // At a MACRO_CALL use site, also probe the macro name itself so
-            // the sibling-arm declaration is marked as referenced and codegen
-            // keeps it. Grammar half of the fix is in 87cb2b5f0.
-            var macroNameAsVarLookup = null;
-            if (_instanceof(child, BaseToken)) {
-                needFindNames = [
-                    child.lexeme
-                ];
-            } else {
-                var callSymbol = child;
-                needFindNames = callSymbol.referenceSymbolNames;
-                var macroName = callSymbol.macroName;
-                if (macroName && needFindNames.indexOf(macroName) === -1) {
-                    needFindNames = needFindNames.concat(macroName);
-                    macroNameAsVarLookup = macroName;
-                }
-            }
+            // Real references — every name must resolve; miss is an authoring error.
+            var needFindNames = _instanceof(child, BaseToken) ? [
+                child.lexeme
+            ] : child.referenceSymbolNames;
             for(var i = 0; i < needFindNames.length; i++){
                 var name = needFindNames[i];
-                // `macroDefineList` short-circuit; bypass for the macro name itself
-                // so cross-arm shadowing can resolve the sibling-arm declaration.
-                if (sa.macroDefineList[name] && name !== macroNameAsVarLookup) {
-                    continue;
-                }
+                if (sa.macroDefineList[name]) continue;
                 // only `macro_call` CFG can reference fnSymbols, others fnSymbols are referenced in `function_call_generic` CFG
                 if (!_instanceof(child, BaseToken) && BuiltinFunction.isExist(name)) {
                     continue;
@@ -4028,29 +4136,24 @@ var TreeNode = /*#__PURE__*/ function() {
                     this.typeInfo = builtinVar.type;
                     continue;
                 }
-                lookupSymbol.set(name, ESymbolType.Any);
-                sa.symbolTableStack.lookupAll(lookupSymbol, true, symbols);
-                if (!symbols.length) ; else {
-                    // Expression-style macros have their own value AST; its real type isn't
-                    // the type of any single `referenceSymbolNames` entry (`v` in `v.v_uv`
-                    // is a `Varyings` struct but the macro call site's type should be the
-                    // member type). Skip type inference for those and keep TypeAny.
-                    if (_instanceof(child, BaseToken) || !child.hasAstValue) {
-                        var _symbols__dataType;
-                        this.typeInfo = (_symbols__dataType = symbols[0].dataType) == null ? void 0 : _symbols__dataType.type;
-                    }
-                    var currentScopeSymbol = sa.symbolTableStack.scope.getSymbol(lookupSymbol, true);
-                    if (currentScopeSymbol) {
-                        if ((_instanceof(currentScopeSymbol, FnSymbol) || currentScopeSymbol.isGlobalVariable) && referenceGlobalSymbolNames.indexOf(name) === -1) {
-                            referenceGlobalSymbolNames.push(name);
-                        }
-                    } else if (symbols.some(function(s) {
-                        return _instanceof(s, FnSymbol) || s.isGlobalVariable;
-                    }) && referenceGlobalSymbolNames.indexOf(name) === -1) {
-                        referenceGlobalSymbolNames.push(name);
-                    }
+                var hit = VariableIdentifier._lookupAndMarkGlobalReference(sa, name, symbols, referenceGlobalSymbolNames, this.location);
+                // Expression-style macros have their own value AST; its real type isn't
+                // the type of any single `referenceSymbolNames` entry (`v` in `v.v_uv`
+                // is a `Varyings` struct but the macro call site's type should be the
+                // member type). Skip type inference for those and keep TypeAny.
+                if (hit && (_instanceof(child, BaseToken) || !child.hasAstValue)) {
+                    var _symbols__dataType;
+                    this.typeInfo = (_symbols__dataType = symbols[0].dataType) == null ? void 0 : _symbols__dataType.type;
                 }
             }
+            // FXAA-style cross-arm shadowing: at a MACRO_CALL use site, silently
+            // probe the macro name itself so any sibling-arm `var` declaration is
+            // marked as referenced and codegen keeps it. Miss is the common
+            // single-arm case — no warning, no type inference. Grammar half of the
+            // cross-arm fix is in 87cb2b5f0.
+            if (!_instanceof(child, BaseToken)) {
+                VariableIdentifier._probeCrossArmShadowing(sa, child, needFindNames, symbols, referenceGlobalSymbolNames);
+            }
         };
         _proto.codeGen = function codeGen(visitor) {
             return this.setCache(visitor.visitVariableIdentifier(this));
@@ -4063,6 +4166,40 @@ var TreeNode = /*#__PURE__*/ function() {
                 return child.codeGen(visitor);
             }
         };
+        /** Run the cross-arm shadowing probe for a MACRO_CALL site. No-op when the
+     *  probe isn't meaningful: no macro name, name already resolved as a real
+     *  reference, or name is a builtin (builtins can't be shadowed by a
+     *  sibling-arm decl). */ VariableIdentifier._probeCrossArmShadowing = function _probeCrossArmShadowing(sa, child, needFindNames, symbols, referenceGlobalSymbolNames) {
+            var macroName = child.macroName;
+            if (!macroName) return;
+            if (needFindNames.indexOf(macroName) !== -1) return; // already looked up as a real reference
+            if (BuiltinFunction.isExist(macroName) || BuiltinVariable.getVar(macroName)) return; // builtins can't be shadowed
+            VariableIdentifier._lookupAndMarkGlobalReference(sa, macroName, symbols, referenceGlobalSymbolNames, null);
+        };
+        /** Look up `name` in the symbol stack and, if a global var/fn declaration
+     *  exists, push it into `referenceGlobalSymbolNames`. Returns `true` iff
+     *  the lookup hit (caller can then derive type info). When `missWarnLoc`
+     *  is non-null, a miss reports a "declared before used" warning; pass
+     *  `null` for silent probes (e.g. FXAA-style cross-arm shadowing).
+     *
+     *  Mutation contract: `symbols` is used as scratch storage — `lookupAll`
+     *  clears and refills it. On hit, the caller may read `symbols[0]` for
+     *  type info before the next call overwrites the contents. */ VariableIdentifier._lookupAndMarkGlobalReference = function _lookupAndMarkGlobalReference(sa, name, symbols, referenceGlobalSymbolNames, missWarnLoc) {
+            var lookupSymbol = SemanticAnalyzer._lookupSymbol;
+            lookupSymbol.set(name, ESymbolType.Any);
+            sa.symbolTableStack.lookupAll(lookupSymbol, true, symbols);
+            if (!symbols.length) {
+                return false;
+            }
+            var currentScopeSymbol = sa.symbolTableStack.scope.getSymbol(lookupSymbol, true);
+            var isGlobal = currentScopeSymbol ? _instanceof(currentScopeSymbol, FnSymbol) || currentScopeSymbol.isGlobalVariable : symbols.some(function(s) {
+                return _instanceof(s, FnSymbol) || s.isGlobalVariable;
+            });
+            if (isGlobal && referenceGlobalSymbolNames.indexOf(name) === -1) {
+                referenceGlobalSymbolNames.push(name);
+            }
+            return true;
+        };
         return VariableIdentifier;
     }(TreeNode);
     ASTNode.VariableIdentifier = VariableIdentifier;
@@ -4319,18 +4456,16 @@ var TreeNode = /*#__PURE__*/ function() {
     MacroBranch = __decorate([
         ASTNodeDecorator(NoneTerminal.macro_branch)
     ], MacroBranch);
-    var MacroCallSymbol = /*#__PURE__*/ function(TreeNode) {
-        _inherits(MacroCallSymbol, TreeNode);
+    var MacroCallSymbol = /*#__PURE__*/ function(TreeNode1) {
+        _inherits(MacroCallSymbol, TreeNode1);
         function MacroCallSymbol() {
             var _this;
-            _this = TreeNode.apply(this, arguments) || this, _this.referenceSymbolNames = [], /** True iff every `MacroDefineInfo` visible from this call site's branch
+            _this = TreeNode1.apply(this, arguments) || this, _this.referenceSymbolNames = [], /** True iff every `MacroDefineInfo` visible from this call site's branch
      *  has a `valueAst` (i.e. was parsed via the `macro_define` CFG rule).
      *  Call sites use this to skip naive type inference: an AST-form macro
      *  drives the call site's type through its own value subtree, not through
      *  a root of `referenceSymbolNames`. Mixed forms across branches → false,
-     *  fall back to legacy inference. */ _this.hasAstValue = false, /** True when the macro is defined as function-like (`#define NAME(params) …`).
-     *  Used by `MacroCallFunction` codegen to pick between the two call shapes
-     *  — object-like-macro-as-function-name vs true function-like macro. */ _this.isFunctionLikeMacro = false;
+     *  fall back to legacy inference. */ _this.hasAstValue = false, /** `#define NAME(params) …` form — drives function-like vs object-like codegen. */ _this.isFunctionLikeMacro = false, /** Every visible replacement is a non-builtin identifier — assume user fn alias. */ _this.aliasesNonBuiltinIdent = false;
             return _this;
         }
         var _proto = MacroCallSymbol.prototype;
@@ -4338,6 +4473,7 @@ var TreeNode = /*#__PURE__*/ function() {
             this.referenceSymbolNames.length = 0;
             this.hasAstValue = false;
             this.isFunctionLikeMacro = false;
+            this.aliasesNonBuiltinIdent = false;
         };
         _proto.semanticAnalyze = function semanticAnalyze(sa) {
             var nameToken = this.children[0];
@@ -4355,6 +4491,7 @@ var TreeNode = /*#__PURE__*/ function() {
             var visibleCount = 0;
             var allAst = true;
             var isFn = false;
+            var allAliasNonBuiltinIdent = true;
             if (defList) {
                 for(var i = 0, n = defList.length; i < n; i++){
                     var info = defList[i];
@@ -4362,8 +4499,30 @@ var TreeNode = /*#__PURE__*/ function() {
                     visibleCount++;
                     if (info.valueAst == null) allAst = false;
                     if (info.isFunction) isFn = true;
-                    var ref = info.referenceName;
-                    if (ref && info.params.indexOf(ref) === -1 && refs.indexOf(ref) === -1) refs.push(ref);
+                    // Harvest references from the value AST. Legacy-form macros (no
+                    // `valueAst`) hold non-expression token sequences with no user
+                    // identifiers, so nothing to collect.
+                    if (info.valueAst) {
+                        MacroCallSymbol._collectIdentifierRefs(info.valueAst, info.params, refs);
+                    }
+                    // aliasesNonBuiltinIdent: macro replacement is a single non-builtin
+                    // identifier — best-effort proxy for "this macro call site aliases a
+                    // user fn", since uniform/const aliases would surface as a GLSL
+                    // compile error later anyway. Keyword replacements (`vec3`, `mat4`)
+                    // reach here with `valueAst === undefined` (opaque path), so they
+                    // automatically fail without an explicit keyword guard.
+                    if (info.isFunction || !info.valueAst) {
+                        allAliasNonBuiltinIdent = false;
+                    } else {
+                        var leadingIdent = ParserUtils.unwrapBareIdentifier(info.valueAst, {
+                            allowParens: false
+                        });
+                        var leadingChild = leadingIdent == null ? void 0 : leadingIdent.children[0];
+                        var leadingId = _instanceof(leadingChild, BaseToken) ? leadingChild.lexeme : undefined;
+                        if (!leadingId || BuiltinFunction.isExist(leadingId)) {
+                            allAliasNonBuiltinIdent = false;
+                        }
+                    }
                 }
             }
             // Require *every* visible entry to be AST-form before taking the AST
@@ -4372,6 +4531,25 @@ var TreeNode = /*#__PURE__*/ function() {
             // instead of polluting the call site with TypeAny.
             this.hasAstValue = visibleCount > 0 && allAst;
             this.isFunctionLikeMacro = isFn;
+            this.aliasesNonBuiltinIdent = visibleCount > 0 && allAliasNonBuiltinIdent;
+        };
+        /** Push every leaf `VariableIdentifier`'s lexeme into `out`, skipping
+     *  function-like parameter names (local to the macro, not call-site refs)
+     *  and duplicates. */ MacroCallSymbol._collectIdentifierRefs = function _collectIdentifierRefs(node, params, out) {
+            if (_instanceof(node, VariableIdentifier)) {
+                var child = node.children[0];
+                if (_instanceof(child, BaseToken)) {
+                    var name = child.lexeme;
+                    if (params.indexOf(name) === -1 && out.indexOf(name) === -1) out.push(name);
+                }
+                return;
+            }
+            var children = node.children;
+            if (!children) return;
+            for(var i = 0, n = children.length; i < n; i++){
+                var c = children[i];
+                if (_instanceof(c, TreeNode)) MacroCallSymbol._collectIdentifierRefs(c, params, out);
+            }
         };
         return MacroCallSymbol;
     }(TreeNode);
@@ -4383,7 +4561,7 @@ var TreeNode = /*#__PURE__*/ function() {
         _inherits(MacroCallFunction, TreeNode);
         function MacroCallFunction() {
             var _this;
-            _this = TreeNode.apply(this, arguments) || this, _this.referenceSymbolNames = [], _this.macroName = "", _this.hasAstValue = false, _this.isFunctionLikeMacro = false;
+            _this = TreeNode.apply(this, arguments) || this, _this.referenceSymbolNames = [], _this.macroName = "", _this.hasAstValue = false, _this.isFunctionLikeMacro = false, _this.aliasesNonBuiltinIdent = false;
             return _this;
         }
         var _proto = MacroCallFunction.prototype;
@@ -4392,6 +4570,7 @@ var TreeNode = /*#__PURE__*/ function() {
             this.macroName = "";
             this.hasAstValue = false;
             this.isFunctionLikeMacro = false;
+            this.aliasesNonBuiltinIdent = false;
         };
         _proto.semanticAnalyze = function semanticAnalyze(sa) {
             var child = this.children[0];
@@ -4399,6 +4578,7 @@ var TreeNode = /*#__PURE__*/ function() {
             this.macroName = child.macroName;
             this.hasAstValue = child.hasAstValue;
             this.isFunctionLikeMacro = child.isFunctionLikeMacro;
+            this.aliasesNonBuiltinIdent = child.aliasesNonBuiltinIdent;
         };
         _proto.codeGen = function codeGen(visitor) {
             return this.setCache(visitor.visitMacroCallFunction(this));
@@ -4434,7 +4614,10 @@ var TreeNode = /*#__PURE__*/ function() {
                 params = ParserUtils.parseMacroParamList(children[2].lexeme);
                 valueIdx = 3;
             }
-            if (_instanceof(children[valueIdx], AssignmentExpression)) {
+            // Grammar's macro_define value is `expression` (not `assignment_expression`),
+            // so the value child is always an `Expression` wrapper — even for a single
+            // assignment-expression value, which appears as `Expression > AssignmentExpression`.
+            if (_instanceof(children[valueIdx], Expression)) {
                 this.valueExpression = children[valueIdx];
             }
             // The Lexer already registered a regex-derived entry for this directive.
@@ -4457,14 +4640,14 @@ var TreeNode = /*#__PURE__*/ function() {
             if (upgradable) {
                 upgradable.valueAst = this.valueExpression;
             } else {
-                // No matching preprocessor entry (e.g. the lexer was fed the directive
-                // directly without a `Preprocessor.parse` pass). Push a fresh entry.
+                // No matching preprocessor entry (lexer fed directly, no
+                // `Preprocessor.parse` pass). Synthetic key based on shape is enough
+                // — this path's only dedup unit is this AST-direct registration.
                 var info = {
                     isFunction: this.isFunction,
-                    name: this.macroName,
                     params: params,
                     valueAst: this.valueExpression,
-                    referenceName: "",
+                    dedupKey: this.macroName + "#ast/" + (this.isFunction ? params.join(",") : ""),
                     branch: definingBranch
                 };
                 if (entries) entries.push(info);
@@ -4472,6 +4655,13 @@ var TreeNode = /*#__PURE__*/ function() {
                     info
                 ];
             }
+            // Close the form-param scope pushed at `MACRO_DEFINE_PARAMS` shift. By
+            // the time this reduce fires, every `VariableIdentifier` inside the
+            // value expression has already resolved against the params. Object-like
+            // macros never pushed a scope, so nothing to pop.
+            if (this.isFunction) {
+                sa.popScope();
+            }
         };
         _proto.codeGen = function codeGen(visitor) {
             return this.setCache(visitor.visitMacroDefine(this));
@@ -4696,30 +4886,24 @@ var TempArray = /*#__PURE__*/ function() {
         if (_instanceof(paramList, ASTNode.FunctionCallParameterList)) {
             var astNodes = paramList.paramNodes;
             var context = VisitorContext.context;
-            // `MacroCallFunction` covers two call shapes sharing the same AST:
-            //   (a) object-like macro whose value is a function name, used as a call —
-            //       `#define FN foo` + `FN(varyings, …)`. The driver expands `FN` to
-            //       `foo`, and `foo` is a shader function whose IO-struct params
-            //       have been flattened. The call site must drop IO-struct args to
-            //       match the flattened signature — same rule as `visitFunctionCall`.
-            //   (b) true function-like macro — `#define MAX3(a,b,c) …` + `MAX3(v.x, …)`.
-            //       The shader compiler doesn't expand the macro; the driver does, and the
-            //       `#define` fixes the parameter count. Args must be preserved
-            //       verbatim — a member-access arg like `v.v_uv` unwraps to a root
-            //       identifier whose type is an IO struct, but dropping the arg
-            //       would change the macro's arity.
-            //
-            // `isFunctionLikeMacro` is set by `MacroCallSymbol.semanticAnalyze` from
-            // `macroDefineList[name][*].isFunction` and carries the definition shape.
-            var params = node.isFunctionLikeMacro ? astNodes : astNodes.filter(function(arg) {
-                if (_instanceof(arg, ASTNode.AssignmentExpression)) {
-                    var variableParam = ParserUtils.unwrapNodeByType(arg, NoneTerminal.variable_identifier);
-                    if (variableParam && typeof variableParam.typeInfo === "string" && context.getStructRole(variableParam.typeInfo)) {
-                        return false;
+            // Drop bare IO-struct args only when the macro aliases a user fn (whose
+            // formal was flattened). All other shapes preserve args verbatim.
+            var params;
+            if (node.isFunctionLikeMacro || !node.aliasesNonBuiltinIdent) {
+                params = astNodes;
+            } else {
+                params = astNodes.filter(function(arg) {
+                    if (_instanceof(arg, ASTNode.AssignmentExpression)) {
+                        var variableParam = ParserUtils.unwrapBareIdentifier(arg, {
+                            allowParens: false
+                        });
+                        if (variableParam && typeof variableParam.typeInfo === "string" && context.getStructRole(variableParam.typeInfo)) {
+                            return false;
+                        }
                     }
-                }
-                return true;
-            });
+                    return true;
+                });
+            }
             var paramsCode = "";
             for(var i = 0, length = params.length; i < length; i++){
                 var argNode = params[i];
@@ -5924,6 +6108,15 @@ var GLES300Visitor = /*#__PURE__*/ function(GLESVisitor) {
 ShaderInstructionEncoder._DIRECTIVE_RE = /^[ \t]*#[ \t]*(if|ifdef|ifndef|elif|else|endif|define|undef)\b(.*)/;
 ShaderInstructionEncoder._FUNC_MACRO_RE = /^(\w+)\(([^)]*)\)\s*(.*)/;
 
+var Production = function Production(goal, derivation) {
+    this.goal = goal;
+    this.derivation = derivation;
+    this.id = Production._id++;
+    Production.pool.set(this.id, this);
+};
+Production._id = 0;
+Production.pool = new Map();
+
 var StateItem = /*#__PURE__*/ function() {
     function StateItem(production, position, lookahead) {
         this._needReInfer = true;
@@ -6286,9 +6479,14 @@ var EAction = /*#__PURE__*/ function(EAction) {
     /** Resolve shift-reduce/reduce-reduce conflict detect */ _proto._addAction = function _addAction(table, terminal, action) {
         var exist = table.get(terminal);
         if (exist && !GrammarUtils.isActionEqual(exist, action)) {
-            // Resolve dangling else ambiguity
-            if (terminal === Keyword.ELSE && exist.action === EAction.Shift && action.action === EAction.Reduce) {
-                return;
+            // Known shift-preferred conflicts (see TargetParser.y `%expect 2`).
+            // Enforce shift regardless of the order `_inferNextState` registers
+            // actions: when `exist` is already Shift and `action` is Reduce, keep
+            // `exist` (early-return); the reverse order (`exist` Reduce, `action`
+            // Shift) falls through to `table.set` below and Shift overwrites
+            // Reduce. Order-independent by construction.
+            if (LALR1._isKnownShiftPreferred(terminal, exist, action)) {
+                if (exist.action === EAction.Shift && action.action === EAction.Reduce) return;
             }
         }
         table.set(terminal, action);
@@ -6340,18 +6538,25 @@ var EAction = /*#__PURE__*/ function(EAction) {
         this._firstSetNTStack.pop();
         return firstSet;
     };
+    // Catalog of expected shift/reduce conflicts. Each entry must correspond to
+    // one of TargetParser.y's `%expect`-ed conflicts; any new conflict not in
+    // this list falls through to the verbose `conflict detect` warning so the
+    // grammar/runtime drift is loud rather than silent.
+    //   - ELSE: dangling-else, bind to nearest `if`
+    //   - '(' + `type_specifier_nonarray → macro_call_symbol`: macro-as-type-alias
+    //     (#2974), prefer the expression-position `macro_call_function` over the
+    //     type-position reduce
+    LALR1._isKnownShiftPreferred = function _isKnownShiftPreferred(terminal, exist, action) {
+        if (terminal === Keyword.ELSE) return true;
+        if (terminal !== ETokenType.LEFT_PAREN) return false;
+        var reduce = exist.action === EAction.Reduce ? exist : action.action === EAction.Reduce ? action : null;
+        if (!reduce) return false;
+        var prod = Production.pool.get(reduce.target);
+        return !!prod && prod.goal === NoneTerminal.type_specifier_nonarray && prod.derivation.length === 1 && prod.derivation[0] === NoneTerminal.macro_call_symbol;
+    };
     return LALR1;
 }();
 
-var Production = function Production(goal, derivation) {
-    this.goal = goal;
-    this.derivation = derivation;
-    this.id = Production._id++;
-    Production.pool.set(this.id, this);
-};
-Production._id = 0;
-Production.pool = new Map();
-
 var Grammar = /*#__PURE__*/ function() {
     function Grammar(start, productions) {
         this.startSymbol = start;
@@ -6421,14 +6626,14 @@ var productionAndRules = [].concat(GrammarUtils.createProductionWithOptions(None
     [
         Keyword.MACRO_DEFINE,
         ETokenType.ID,
-        NoneTerminal.assignment_expression,
+        NoneTerminal.expression,
         Keyword.MACRO_DEFINE_END
     ],
     [
         Keyword.MACRO_DEFINE,
         ETokenType.ID,
         Keyword.MACRO_DEFINE_PARAMS,
-        NoneTerminal.assignment_expression,
+        NoneTerminal.expression,
         Keyword.MACRO_DEFINE_END
     ]
 ], ASTNode.MacroDefine.pool), GrammarUtils.createProductionWithOptions(NoneTerminal.macro_call_symbol, [
@@ -7795,6 +8000,19 @@ var addTranslationRule = function(sa) {
             var actionInfo = this.stateActionTable.get(token.type);
             if ((actionInfo == null ? void 0 : actionInfo.action) === EAction.Shift) {
                 traceBackStack.push(token, actionInfo.target);
+                // Function-like `#define` form params live in a scope wrapping the
+                // value AST, mirroring how `function_header` opens a scope for GLSL
+                // function parameters. Push on shift of `MACRO_DEFINE_PARAMS`; the
+                // matching `popScope` runs when `MacroDefine.semanticAnalyze` reduces
+                // the production (only the function-like alternative needs it, and
+                // it knows that from its own children).
+                if (token.type === Keyword.MACRO_DEFINE_PARAMS) {
+                    sematicAnalyzer.pushScope();
+                    for(var _iterator = _create_for_of_iterator_helper_loose(ParserUtils.parseMacroParamList(token.lexeme)), _step; !(_step = _iterator()).done;){
+                        var p = _step.value;
+                        sematicAnalyzer.symbolTableStack.insert(new SymbolInfo(p, ESymbolType.VAR));
+                    }
+                }
                 nextToken = tokens.next();
             } else if ((actionInfo == null ? void 0 : actionInfo.action) === EAction.Accept) {
                 sematicAnalyzer.acceptRule == null ? void 0 : sematicAnalyzer.acceptRule.call(sematicAnalyzer, sematicAnalyzer);
@@ -8702,7 +8920,7 @@ ShaderCompiler._shaderPositionPool = ShaderCompilerUtils.createObjectPool(Shader
 ShaderCompiler._shaderRangePool = ShaderCompilerUtils.createObjectPool(ShaderRange);
 
 //@ts-ignore
-var version = "2.0.0-alpha.32";
+var version = "2.0.0-alpha.33";
 var mode = "Release";
 console.log("Galacean Engine Shader Compiler Version: " + version + " | Mode: " + mode);