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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-shader-compiler",
-  "version": "2.0.0-alpha.32",
+  "version": "2.0.0-alpha.33",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -21,10 +21,15 @@
       "types": "./types/index.d.ts"
     },
     "./bundler/rollup": {
-      "import": "./dist/bundler/rollup.js",
-      "require": "./dist/bundler/rollup.cjs.js",
+      "import": "./bundler/rollup.js",
+      "require": "./bundler/rollup.cjs.js",
       "types": "./types/bundler/rollup.d.ts"
     },
+    "./bundler/precompile": {
+      "import": "./bundler/precompile.js",
+      "require": "./bundler/precompile.cjs.js",
+      "types": "./types/bundler/precompile.d.ts"
+    },
     "./verbose": {
       "import": "./dist/module.verbose.js",
       "require": "./dist/main.verbose.js",
@@ -34,7 +39,7 @@
     "./package.json": "./package.json"
   },
   "bin": {
-    "shader-compiler-precompile": "./dist/bundler/cli.js"
+    "shader-compiler-precompile": "./bundler/cli.js"
   },
   "umd": {
     "name": "Galacean.ShaderCompiler",
@@ -45,19 +50,20 @@
   },
   "files": [
     "dist/**/*",
+    "bundler/**/*",
     "types/**/*",
     "verbose/package.json"
   ],
   "dependencies": {
     "@rollup/pluginutils": "^5.0.0",
-    "@galacean/engine-math": "2.0.0-alpha.32",
-    "@galacean/engine-core": "2.0.0-alpha.32"
+    "@galacean/engine-math": "2.0.0-alpha.33",
+    "@galacean/engine-core": "2.0.0-alpha.33"
   },
   "devDependencies": {
-    "@galacean/engine-design": "2.0.0-alpha.32"
+    "@galacean/engine-design": "2.0.0-alpha.33"
   },
   "scripts": {
-    "build": "rollup -c rollup.config.js && chmod +x dist/bundler/cli.js",
+    "build": "rollup -c rollup.config.js && chmod +x bundler/cli.js",
     "b:types": "tsc"
   }
 }

package/types/ParserUtils.d.ts

@@ -1,5 +1,5 @@
 import { GalaceanDataType } from "./common";
-import { TreeNode } from "./parser/AST";
+import { ASTNode, TreeNode } from "./parser/AST";
 import { GrammarSymbol, NoneTerminal } from "./parser/GrammarSymbol";
 export declare class ParserUtils {
     static unwrapNodeByType<T = TreeNode>(node: TreeNode, type: NoneTerminal): T | undefined;
@@ -10,11 +10,24 @@ export declare class ParserUtils {
      */
     static parseMacroParamList(lexeme: string): string[];
     /**
-     * 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.
+     * 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.
+     */
+    static unwrapBareIdentifier(node: TreeNode, options: {
+        allowParens: boolean;
+    }): ASTNode.VariableIdentifier | undefined;
+    /**
+     * Lexeme variant of `unwrapBareIdentifier({ allowParens: true })` for callers
+     * that already work with strings. Returns `null` for compound expressions.
      */
     static extractDirectIdentLexeme(expr: TreeNode): string | null;
     /**

package/types/Preprocessor.d.ts

@@ -4,23 +4,20 @@ export type IncludeMap = {
     readonly [includeName: string]: string | undefined;
 };
 export type ChunkOutputCache = Map<string, string>;
-/**
- * Record for a single `#define` directive. `valueAst` is set for expression
- * macros (joined into the AST pipeline); opaque macros leave it undefined and
- * are emitted verbatim to the GLSL driver.
- */
 export interface MacroDefineInfo {
     isFunction: boolean;
-    name: string;
     params: string[];
-    valueAst?: ASTNode.AssignmentExpression;
-    /** Leading identifier of the value (`#define F foo` → `foo`, `#define F foo(a)`
-     *  → `foo`), or empty for literals / operator expressions. Drives symbol-table
-     *  lookup at macro call sites. */
-    referenceName: string;
-    /** Branch signature at the point of registration. The same `#define` repeated
-     *  in different `#ifdef` branches produces multiple entries with different
-     *  signatures; call sites filter to those visible from their own position. */
+    /** Value AST. Set when the replacement list parses as `expression` (which
+     *  includes comma-separated lists per C99 §6.10.3); absent for the GLSL ES
+     *  3.00 §3.4 opaque cases the grammar can't reduce (empty, type-alias keyword,
+     *  trailing punctuation, unbalanced bracket, trailing operator). Identifier
+     *  references inside are collected by `MacroCallSymbol._collectIdentifierRefs`
+     *  walking this subtree. */
+    valueAst?: ASTNode.Expression;
+    /** Whitespace-normalized directive text. Dedup key against re-includes in
+     *  the same branch; differing values produce different keys. */
+    dedupKey: string;
+    /** `#ifdef` branch at registration time; call sites filter to visible entries. */
     branch: BranchSignature;
 }
 export interface MacroDefineList {

package/types/ShaderCompilerUtils.d.ts

@@ -6,5 +6,5 @@ export declare class ShaderCompilerUtils {
     private static _shaderCompilerObjectPoolSet;
     static createObjectPool<T extends IPoolElement>(type: new () => T): ClearableObjectPool<T>;
     static clearAllShaderCompilerObjectPool(): void;
-    static createGSError(message: string, errorName: GSErrorName, source: string, location: ShaderRange | ShaderPosition, file?: string): Error | undefined;
+    static createGSError(message: string, errorName: GSErrorName, source: string, location: ShaderRange | ShaderPosition, file?: string): Error;
 }

package/types/lalr/LALR1.d.ts

@@ -21,6 +21,7 @@ export declare class LALR1 {
     private _inferNextState;
     /** Resolve shift-reduce/reduce-reduce conflict detect */
     private _addAction;
+    private static _isKnownShiftPreferred;
     private computeFirstSet;
     private _computeFirstSetForNT;
 }

package/types/lexer/Lexer.d.ts

@@ -7,9 +7,6 @@ import { MacroDefineList } from "../Preprocessor";
 export declare class Lexer extends BaseLexer {
     macroDefineList: MacroDefineList;
     private static _lexemeTable;
-    private static readonly _defineDirectiveReg;
-    private static readonly _referenceReg;
-    private static readonly _lineContinuationReg;
     private static _ifCounter;
     /** Two branch signatures are equal iff they have the same constraints in the
      *  same order with the same polarity. Used by `#define` dedup and AST upgrade
@@ -33,7 +30,9 @@ export declare class Lexer extends BaseLexer {
     private _inMacroDefineValue;
     private _macroDefineExpectsNameToken;
     private _macroDefineExpectsParamsToken;
-    private _macroDefineDirectiveStart;
+    private _currentMacroName;
+    private _currentMacroParamsLexeme;
+    private _currentMacroValueStart;
     private _branchStack;
     private _pendingBranchPushDefined;
     tokenize(): Generator<BaseToken<number>, BaseToken<number>, unknown>;
@@ -46,22 +45,52 @@ export declare class Lexer extends BaseLexer {
     /** True if the current char is an unescaped line break (ignoring `\` continuation). */
     private _isAtLineBreak;
     /**
-     * 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 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.
+     * The replacement list is split three ways:
      *
-     * 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.
+     *  - **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).
+     *
+     *  - **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).
      */
-    private _defineHasValue;
+    private _peekMacroDefine;
+    /** 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. */
+    private static _isNonExpressionLeadingKeyword;
     /**
      * 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
@@ -69,8 +98,7 @@ export declare class Lexer extends BaseLexer {
      * 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.
      */
     private static _skipLineContinuation;
     /**
@@ -101,6 +129,10 @@ export declare class Lexer extends BaseLexer {
     /** Emit `MACRO_DEFINE_END` at the end of a `#define` value, consuming the newline. */
     private _emitMacroDefineEnd;
     private _registerMacroDefine;
+    /** 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. */
+    private static _normalizeValueText;
     private _scanMacroConditionExpression;
     private _scanWord;
     /** True iff at least one `#define <word>` is reachable from the current branch. */

package/types/parser/AST.d.ts

@@ -383,6 +383,21 @@ export declare namespace ASTNode {
         private _symbols;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
+        /** 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). */
+        private static _probeCrossArmShadowing;
+        /** 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. */
+        private static _lookupAndMarkGlobalReference;
         codeGen(visitor: CodeGenVisitor): string;
         getLexeme(visitor: CodeGenVisitor): string;
     }
@@ -442,18 +457,23 @@ export declare namespace ASTNode {
          *  a root of `referenceSymbolNames`. Mixed forms across branches → false,
          *  fall back to legacy inference. */
         hasAstValue: boolean;
-        /** 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. */
+        /** `#define NAME(params) …` form — drives function-like vs object-like codegen. */
         isFunctionLikeMacro: boolean;
+        /** Every visible replacement is a non-builtin identifier — assume user fn alias. */
+        aliasesNonBuiltinIdent: boolean;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
+        /** Push every leaf `VariableIdentifier`'s lexeme into `out`, skipping
+         *  function-like parameter names (local to the macro, not call-site refs)
+         *  and duplicates. */
+        private static _collectIdentifierRefs;
     }
     export class MacroCallFunction extends TreeNode {
         referenceSymbolNames: string[];
         macroName: string;
         hasAstValue: boolean;
         isFunctionLikeMacro: boolean;
+        aliasesNonBuiltinIdent: boolean;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
@@ -473,7 +493,7 @@ export declare namespace ASTNode {
     export class MacroDefine extends TreeNode {
         macroName: string;
         isFunction: boolean;
-        valueExpression?: AssignmentExpression;
+        valueExpression?: Expression;
         init(): void;
         semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;