@luma.gl/engine 9.0.15 → 9.0.16

package/dist/dist.dev.js

@@ -1833,7 +1833,7 @@ void main() {
   // ../shadertools/src/lib/wgsl/get-shader-layout-wgsl.ts
   var import_core4 = __toESM(require_core(), 1);
 
-  // ../shadertools/src/libs/wgsl-reflect/wgsl_reflect.module.js
+  // ../../node_modules/wgsl_reflect/wgsl_reflect.module.js
   var ParseContext = class {
     constructor() {
       this.constants = /* @__PURE__ */ new Map();
@@ -1856,23 +1856,50 @@ void main() {
     evaluateString(context) {
       return this.evaluate(context).toString();
     }
+    search(callback) {
+    }
+    searchBlock(block, callback) {
+      if (block) {
+        callback(_BlockStart.instance);
+        for (const node of block) {
+          if (node instanceof Array) {
+            this.searchBlock(node, callback);
+          } else {
+            node.search(callback);
+          }
+        }
+        callback(_BlockEnd.instance);
+      }
+    }
+  };
+  var _BlockStart = class extends Node {
+  };
+  _BlockStart.instance = new _BlockStart();
+  var _BlockEnd = class extends Node {
   };
+  _BlockEnd.instance = new _BlockEnd();
   var Statement = class extends Node {
     constructor() {
       super();
     }
   };
   var Function = class extends Statement {
-    constructor(name, args, returnType, body) {
+    constructor(name, args, returnType, body, startLine, endLine) {
       super();
+      this.calls = /* @__PURE__ */ new Set();
       this.name = name;
       this.args = args;
       this.returnType = returnType;
       this.body = body;
+      this.startLine = startLine;
+      this.endLine = endLine;
     }
     get astNodeType() {
       return "function";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var StaticAssert = class extends Statement {
     constructor(expression) {
@@ -1882,6 +1909,9 @@ void main() {
     get astNodeType() {
       return "staticAssert";
     }
+    search(callback) {
+      this.expression.search(callback);
+    }
   };
   var While = class extends Statement {
     constructor(condition, body) {
@@ -1892,6 +1922,10 @@ void main() {
     get astNodeType() {
       return "while";
     }
+    search(callback) {
+      this.condition.search(callback);
+      this.searchBlock(this.body, callback);
+    }
   };
   var Continuing = class extends Statement {
     constructor(body) {
@@ -1901,6 +1935,9 @@ void main() {
     get astNodeType() {
       return "continuing";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var For = class extends Statement {
     constructor(init, condition, increment, body) {
@@ -1913,6 +1950,13 @@ void main() {
     get astNodeType() {
       return "for";
     }
+    search(callback) {
+      var _a2, _b, _c;
+      (_a2 = this.init) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+      (_b = this.condition) === null || _b === void 0 ? void 0 : _b.search(callback);
+      (_c = this.increment) === null || _c === void 0 ? void 0 : _c.search(callback);
+      this.searchBlock(this.body, callback);
+    }
   };
   var Var = class extends Statement {
     constructor(name, type, storage, access, value) {
@@ -1926,6 +1970,11 @@ void main() {
     get astNodeType() {
       return "var";
     }
+    search(callback) {
+      var _a2;
+      callback(this);
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Override = class extends Statement {
     constructor(name, type, value) {
@@ -1937,6 +1986,10 @@ void main() {
     get astNodeType() {
       return "override";
     }
+    search(callback) {
+      var _a2;
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Let = class extends Statement {
     constructor(name, type, storage, access, value) {
@@ -1950,6 +2003,11 @@ void main() {
     get astNodeType() {
       return "let";
     }
+    search(callback) {
+      var _a2;
+      callback(this);
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Const = class extends Statement {
     constructor(name, type, storage, access, value) {
@@ -1966,6 +2024,11 @@ void main() {
     evaluate(context) {
       return this.value.evaluate(context);
     }
+    search(callback) {
+      var _a2;
+      callback(this);
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var IncrementOperator;
   (function(IncrementOperator2) {
@@ -1990,6 +2053,9 @@ void main() {
     get astNodeType() {
       return "increment";
     }
+    search(callback) {
+      this.variable.search(callback);
+    }
   };
   var AssignOperator;
   (function(AssignOperator2) {
@@ -2008,9 +2074,10 @@ void main() {
   (function(AssignOperator2) {
     function parse(val) {
       const key = val;
-      if (key == "parse")
+      if (key == "parse") {
         throw new Error("Invalid value for AssignOperator");
-      return AssignOperator2[key];
+      }
+      return key;
     }
     AssignOperator2.parse = parse;
   })(AssignOperator || (AssignOperator = {}));
@@ -2024,6 +2091,10 @@ void main() {
     get astNodeType() {
       return "assign";
     }
+    search(callback) {
+      this.variable.search(callback);
+      this.value.search(callback);
+    }
   };
   var Call = class extends Statement {
     constructor(name, args) {
@@ -2034,6 +2105,12 @@ void main() {
     get astNodeType() {
       return "call";
     }
+    search(callback) {
+      for (const node of this.args) {
+        node.search(callback);
+      }
+      callback(this);
+    }
   };
   var Loop = class extends Statement {
     constructor(body, continuing) {
@@ -2066,6 +2143,12 @@ void main() {
     get astNodeType() {
       return "if";
     }
+    search(callback) {
+      this.condition.search(callback);
+      this.searchBlock(this.body, callback);
+      this.searchBlock(this.elseif, callback);
+      this.searchBlock(this.else, callback);
+    }
   };
   var Return = class extends Statement {
     constructor(value) {
@@ -2075,6 +2158,10 @@ void main() {
     get astNodeType() {
       return "return";
     }
+    search(callback) {
+      var _a2;
+      (_a2 = this.value) === null || _a2 === void 0 ? void 0 : _a2.search(callback);
+    }
   };
   var Enable = class extends Statement {
     constructor(name) {
@@ -2085,6 +2172,25 @@ void main() {
       return "enable";
     }
   };
+  var Requires = class extends Statement {
+    constructor(extensions) {
+      super();
+      this.extensions = extensions;
+    }
+    get astNodeType() {
+      return "requires";
+    }
+  };
+  var Diagnostic = class extends Statement {
+    constructor(severity, rule) {
+      super();
+      this.severity = severity;
+      this.rule = rule;
+    }
+    get astNodeType() {
+      return "diagnostic";
+    }
+  };
   var Alias = class extends Statement {
     constructor(name, type) {
       super();
@@ -2135,9 +2241,11 @@ void main() {
     }
   };
   var Struct = class extends Type {
-    constructor(name, members) {
+    constructor(name, members, startLine, endLine) {
       super(name);
       this.members = members;
+      this.startLine = startLine;
+      this.endLine = endLine;
     }
     get astNodeType() {
       return "struct";
@@ -2228,6 +2336,12 @@ void main() {
     get astNodeType() {
       return "createExpr";
     }
+    search(callback) {
+      callback(this);
+      for (const node of this.args) {
+        node.search(callback);
+      }
+    }
   };
   var CallExpr = class extends Expression {
     constructor(name, args) {
@@ -2321,6 +2435,12 @@ void main() {
           throw new Error("Non const function: " + this.name);
       }
     }
+    search(callback) {
+      for (const node of this.args) {
+        node.search(callback);
+      }
+      callback(this);
+    }
   };
   var VariableExpr = class extends Expression {
     constructor(name) {
@@ -2330,6 +2450,19 @@ void main() {
     get astNodeType() {
       return "varExpr";
     }
+    search(callback) {
+      callback(this);
+      if (this.postfix) {
+        this.postfix.search(callback);
+      }
+    }
+    evaluate(context) {
+      const constant = context.constants.get(this.name);
+      if (!constant) {
+        throw new Error("Cannot evaluate node");
+      }
+      return constant.evaluate(context);
+    }
   };
   var ConstExpr = class extends Expression {
     constructor(name, initializer) {
@@ -2355,6 +2488,9 @@ void main() {
       }
       return this.initializer.evaluate(context);
     }
+    search(callback) {
+      this.initializer.search(callback);
+    }
   };
   var LiteralExpr = class extends Expression {
     constructor(value) {
@@ -2377,6 +2513,9 @@ void main() {
     get astNodeType() {
       return "bitcastExpr";
     }
+    search(callback) {
+      this.value.search(callback);
+    }
   };
   var TypecastExpr = class extends Expression {
     constructor(type, args) {
@@ -2390,6 +2529,9 @@ void main() {
     evaluate(context) {
       return this.args[0].evaluate(context);
     }
+    search(callback) {
+      this.searchBlock(this.args, callback);
+    }
   };
   var GroupingExpr = class extends Expression {
     constructor(contents) {
@@ -2402,6 +2544,18 @@ void main() {
     evaluate(context) {
       return this.contents[0].evaluate(context);
     }
+    search(callback) {
+      this.searchBlock(this.contents, callback);
+    }
+  };
+  var ArrayIndex = class extends Expression {
+    constructor(index2) {
+      super();
+      this.index = index2;
+    }
+    search(callback) {
+      this.index.search(callback);
+    }
   };
   var Operator = class extends Expression {
     constructor() {
@@ -2431,6 +2585,9 @@ void main() {
           throw new Error("Unknown unary operator: " + this.operator);
       }
     }
+    search(callback) {
+      this.right.search(callback);
+    }
   };
   var BinaryOperator = class extends Operator {
     constructor(operator, left, right) {
@@ -2474,6 +2631,10 @@ void main() {
           throw new Error(`Unknown operator ${this.operator}`);
       }
     }
+    search(callback) {
+      this.left.search(callback);
+      this.right.search(callback);
+    }
   };
   var SwitchCase = class extends Node {
     constructor() {
@@ -2489,6 +2650,9 @@ void main() {
     get astNodeType() {
       return "case";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var Default = class extends SwitchCase {
     constructor(body) {
@@ -2498,6 +2662,9 @@ void main() {
     get astNodeType() {
       return "default";
     }
+    search(callback) {
+      this.searchBlock(this.body, callback);
+    }
   };
   var Argument = class extends Node {
     constructor(name, type, attributes) {
@@ -2519,6 +2686,10 @@ void main() {
     get astNodeType() {
       return "elseif";
     }
+    search(callback) {
+      this.condition.search(callback);
+      this.searchBlock(this.body, callback);
+    }
   };
   var Member = class extends Node {
     constructor(name, type, attributes) {
@@ -2633,6 +2804,7 @@ void main() {
     continue: new TokenType("continue", TokenClass.keyword, "continue"),
     continuing: new TokenType("continuing", TokenClass.keyword, "continuing"),
     default: new TokenType("default", TokenClass.keyword, "default"),
+    diagnostic: new TokenType("diagnostic", TokenClass.keyword, "diagnostic"),
     discard: new TokenType("discard", TokenClass.keyword, "discard"),
     else: new TokenType("else", TokenClass.keyword, "else"),
     enable: new TokenType("enable", TokenClass.keyword, "enable"),
@@ -2650,6 +2822,7 @@ void main() {
     read: new TokenType("read", TokenClass.keyword, "read"),
     read_write: new TokenType("read_write", TokenClass.keyword, "read_write"),
     return: new TokenType("return", TokenClass.keyword, "return"),
+    requires: new TokenType("requires", TokenClass.keyword, "requires"),
     storage: new TokenType("storage", TokenClass.keyword, "storage"),
     switch: new TokenType("switch", TokenClass.keyword, "switch"),
     true: new TokenType("true", TokenClass.keyword, "true"),
@@ -2708,13 +2881,11 @@ void main() {
     hex_float_literal: new TokenType("hex_float_literal", TokenClass.token, /-?0x((([0-9a-fA-F]*\.[0-9a-fA-F]+|[0-9a-fA-F]+\.[0-9a-fA-F]*)((p|P)(\+|-)?[0-9]+f?)?)|([0-9a-fA-F]+(p|P)(\+|-)?[0-9]+f?))/),
     int_literal: new TokenType("int_literal", TokenClass.token, /-?0x[0-9a-fA-F]+|0i?|-?[1-9][0-9]*i?/),
     uint_literal: new TokenType("uint_literal", TokenClass.token, /0x[0-9a-fA-F]+u|0u|[1-9][0-9]*u/),
-    ident: new TokenType("ident", TokenClass.token, /[a-zA-Z][0-9a-zA-Z_]*/),
+    ident: new TokenType("ident", TokenClass.token, /[_a-zA-Z][0-9a-zA-Z_]*/),
     and: new TokenType("and", TokenClass.token, "&"),
     and_and: new TokenType("and_and", TokenClass.token, "&&"),
     arrow: new TokenType("arrow ", TokenClass.token, "->"),
     attr: new TokenType("attr", TokenClass.token, "@"),
-    attr_left: new TokenType("attr_left", TokenClass.token, "[["),
-    attr_right: new TokenType("attr_right", TokenClass.token, "]]"),
     forward_slash: new TokenType("forward_slash", TokenClass.token, "/"),
     bang: new TokenType("bang", TokenClass.token, "!"),
     bracket_left: new TokenType("bracket_left", TokenClass.token, "["),
@@ -2758,6 +2929,63 @@ void main() {
     shift_right_equal: new TokenType("shift_right_equal", TokenClass.token, ">>="),
     shift_left_equal: new TokenType("shift_left_equal", TokenClass.token, "<<=")
   };
+  TokenTypes.simpleTokens = {
+    "@": _a.tokens.attr,
+    "{": _a.tokens.brace_left,
+    "}": _a.tokens.brace_right,
+    ":": _a.tokens.colon,
+    ",": _a.tokens.comma,
+    "(": _a.tokens.paren_left,
+    ")": _a.tokens.paren_right,
+    ";": _a.tokens.semicolon
+  };
+  TokenTypes.literalTokens = {
+    "&": _a.tokens.and,
+    "&&": _a.tokens.and_and,
+    "->": _a.tokens.arrow,
+    "/": _a.tokens.forward_slash,
+    "!": _a.tokens.bang,
+    "[": _a.tokens.bracket_left,
+    "]": _a.tokens.bracket_right,
+    "=": _a.tokens.equal,
+    "==": _a.tokens.equal_equal,
+    "!=": _a.tokens.not_equal,
+    ">": _a.tokens.greater_than,
+    ">=": _a.tokens.greater_than_equal,
+    ">>": _a.tokens.shift_right,
+    "<": _a.tokens.less_than,
+    "<=": _a.tokens.less_than_equal,
+    "<<": _a.tokens.shift_left,
+    "%": _a.tokens.modulo,
+    "-": _a.tokens.minus,
+    "--": _a.tokens.minus_minus,
+    ".": _a.tokens.period,
+    "+": _a.tokens.plus,
+    "++": _a.tokens.plus_plus,
+    "|": _a.tokens.or,
+    "||": _a.tokens.or_or,
+    "*": _a.tokens.star,
+    "~": _a.tokens.tilde,
+    "_": _a.tokens.underscore,
+    "^": _a.tokens.xor,
+    "+=": _a.tokens.plus_equal,
+    "-=": _a.tokens.minus_equal,
+    "*=": _a.tokens.times_equal,
+    "/=": _a.tokens.division_equal,
+    "%=": _a.tokens.modulo_equal,
+    "&=": _a.tokens.and_equal,
+    "|=": _a.tokens.or_equal,
+    "^=": _a.tokens.xor_equal,
+    ">>=": _a.tokens.shift_right_equal,
+    "<<=": _a.tokens.shift_left_equal
+  };
+  TokenTypes.regexTokens = {
+    decimal_float_literal: _a.tokens.decimal_float_literal,
+    hex_float_literal: _a.tokens.hex_float_literal,
+    int_literal: _a.tokens.int_literal,
+    uint_literal: _a.tokens.uint_literal,
+    ident: _a.tokens.ident
+  };
   TokenTypes.storage_class = [
     _a.keywords.function,
     _a.keywords.private,
@@ -2880,7 +3108,7 @@ void main() {
     _a.keywords.bitcast,
     ..._a.any_texture_type
   ];
-  TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block];
+  TokenTypes.attribute_name = [_a.tokens.ident, _a.keywords.block, _a.keywords.diagnostic];
   TokenTypes.assignment_operators = [
     _a.tokens.equal,
     _a.tokens.plus_equal,
@@ -2929,8 +3157,9 @@ void main() {
     scanTokens() {
       while (!this._isAtEnd()) {
         this._start = this._current;
-        if (!this.scanToken())
+        if (!this.scanToken()) {
           throw `Invalid syntax at line ${this._line}`;
+        }
       }
       this._tokens.push(new Token(TokenTypes.eof, "", this._line));
       return this._tokens;
@@ -2948,8 +3177,9 @@ void main() {
       if (lexeme == "/") {
         if (this._peekAhead() == "/") {
           while (lexeme != "\n") {
-            if (this._isAtEnd())
+            if (this._isAtEnd()) {
               return true;
+            }
             lexeme = this._advance();
           }
           this._line++;
@@ -2958,8 +3188,9 @@ void main() {
           this._advance();
           let commentLevel = 1;
           while (commentLevel > 0) {
-            if (this._isAtEnd())
+            if (this._isAtEnd()) {
               return true;
+            }
             lexeme = this._advance();
             if (lexeme == "\n") {
               this._line++;
@@ -2981,7 +3212,32 @@ void main() {
           return true;
         }
       }
+      const simpleToken = TokenTypes.simpleTokens[lexeme];
+      if (simpleToken) {
+        this._addToken(simpleToken);
+        return true;
+      }
       let matchType = TokenTypes.none;
+      const isAlpha = this._isAlpha(lexeme);
+      const isUnderscore = lexeme === "_";
+      if (this._isAlphaNumeric(lexeme)) {
+        let nextChar = this._peekAhead();
+        while (this._isAlphaNumeric(nextChar)) {
+          lexeme += this._advance();
+          nextChar = this._peekAhead();
+        }
+      }
+      if (isAlpha) {
+        const matchedType = TokenTypes.keywords[lexeme];
+        if (matchedType) {
+          this._addToken(matchedType);
+          return true;
+        }
+      }
+      if (isAlpha || isUnderscore) {
+        this._addToken(TokenTypes.tokens.ident);
+        return true;
+      }
       for (; ; ) {
         let matchedType = this._findType(lexeme);
         const nextLexeme = this._peekAhead();
@@ -3014,8 +3270,9 @@ void main() {
             }
           }
           if (matchedType === TokenTypes.none) {
-            if (matchType === TokenTypes.none)
+            if (matchType === TokenTypes.none) {
               return false;
+            }
             this._current--;
             this._addToken(matchType);
             return true;
@@ -3024,45 +3281,43 @@ void main() {
           this._current += lookAhead + 1;
         }
         matchType = matchedType;
-        if (this._isAtEnd())
+        if (this._isAtEnd()) {
           break;
+        }
         lexeme += this._advance();
       }
-      if (matchType === TokenTypes.none)
+      if (matchType === TokenTypes.none) {
         return false;
+      }
       this._addToken(matchType);
       return true;
     }
     _findType(lexeme) {
-      for (const name in TokenTypes.keywords) {
-        const type = TokenTypes.keywords[name];
-        if (this._match(lexeme, type.rule)) {
-          return type;
+      for (const name in TokenTypes.regexTokens) {
+        const type2 = TokenTypes.regexTokens[name];
+        if (this._match(lexeme, type2.rule)) {
+          return type2;
         }
       }
-      for (const name in TokenTypes.tokens) {
-        const type = TokenTypes.tokens[name];
-        if (this._match(lexeme, type.rule)) {
-          return type;
-        }
+      const type = TokenTypes.literalTokens[lexeme];
+      if (type) {
+        return type;
       }
       return TokenTypes.none;
     }
     _match(lexeme, rule) {
-      if (typeof rule === "string") {
-        if (rule == lexeme) {
-          return true;
-        }
-      } else {
-        const match = rule.exec(lexeme);
-        if (match && match.index == 0 && match[0] == lexeme)
-          return true;
-      }
-      return false;
+      const match = rule.exec(lexeme);
+      return match && match.index == 0 && match[0] == lexeme;
     }
     _isAtEnd() {
       return this._current >= this._source.length;
     }
+    _isAlpha(c) {
+      return c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+    }
+    _isAlphaNumeric(c) {
+      return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c == "_" || c >= "0" && c <= "9";
+    }
     _isWhitespace(c) {
       return c == " " || c == "	" || c == "\r";
     }
@@ -3075,8 +3330,9 @@ void main() {
     }
     _peekAhead(offset = 0) {
       offset = offset || 0;
-      if (this._current + offset >= this._source.length)
+      if (this._current + offset >= this._source.length) {
         return "\0";
+      }
       return this._source[this._current + offset];
     }
     _addToken(type) {
@@ -3088,17 +3344,40 @@ void main() {
     constructor() {
       this._tokens = [];
       this._current = 0;
+      this._currentLine = 0;
       this._context = new ParseContext();
+      this._deferArrayCountEval = [];
     }
     parse(tokensOrCode) {
       this._initialize(tokensOrCode);
-      let statements = [];
+      this._deferArrayCountEval.length = 0;
+      const statements = [];
       while (!this._isAtEnd()) {
         const statement = this._global_decl_or_directive();
-        if (!statement)
+        if (!statement) {
           break;
+        }
         statements.push(statement);
       }
+      if (this._deferArrayCountEval.length > 0) {
+        for (const arrayDecl of this._deferArrayCountEval) {
+          const arrayType = arrayDecl["arrayType"];
+          const countNode = arrayDecl["countNode"];
+          if (countNode instanceof VariableExpr) {
+            const variable = countNode;
+            const name = variable.name;
+            const constant = this._context.constants.get(name);
+            if (constant) {
+              try {
+                const count = constant.evaluate(this._context);
+                arrayType.count = count;
+              } catch (e) {
+              }
+            }
+          }
+        }
+        this._deferArrayCountEval.length = 0;
+      }
       return statements;
     }
     _initialize(tokensOrCode) {
@@ -3115,7 +3394,6 @@ void main() {
       this._current = 0;
     }
     _error(token, message) {
-      console.error(token, message);
       return {
         token,
         message,
@@ -3145,24 +3423,29 @@ void main() {
       return false;
     }
     _consume(types, message) {
-      if (this._check(types))
+      if (this._check(types)) {
         return this._advance();
+      }
       throw this._error(this._peek(), message);
     }
     _check(types) {
-      if (this._isAtEnd())
+      if (this._isAtEnd()) {
         return false;
+      }
       const tk = this._peek();
       if (types instanceof Array) {
-        let t = tk.type;
-        let index2 = types.indexOf(t);
+        const t = tk.type;
+        const index2 = types.indexOf(t);
         return index2 != -1;
       }
       return tk.type == types;
     }
     _advance() {
-      if (!this._isAtEnd())
+      var _a2, _b;
+      this._currentLine = (_b = (_a2 = this._peek()) === null || _a2 === void 0 ? void 0 : _a2.line) !== null && _b !== void 0 ? _b : -1;
+      if (!this._isAtEnd()) {
         this._current++;
+      }
       return this._previous();
     }
     _peek() {
@@ -3179,6 +3462,16 @@ void main() {
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
         return type;
       }
+      if (this._match(TokenTypes.keywords.diagnostic)) {
+        const directive = this._diagnostic();
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return directive;
+      }
+      if (this._match(TokenTypes.keywords.requires)) {
+        const requires = this._requires_directive();
+        this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
+        return requires;
+      }
       if (this._match(TokenTypes.keywords.enable)) {
         const enable = this._enable_directive();
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'");
@@ -3187,56 +3480,65 @@ void main() {
       const attrs = this._attribute();
       if (this._check(TokenTypes.keywords.var)) {
         const _var = this._global_variable_decl();
-        if (_var != null)
+        if (_var != null) {
           _var.attributes = attrs;
+        }
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
         return _var;
       }
       if (this._check(TokenTypes.keywords.override)) {
         const _override = this._override_variable_decl();
-        if (_override != null)
+        if (_override != null) {
           _override.attributes = attrs;
+        }
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
         return _override;
       }
       if (this._check(TokenTypes.keywords.let)) {
         const _let = this._global_let_decl();
-        if (_let != null)
+        if (_let != null) {
           _let.attributes = attrs;
+        }
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
         return _let;
       }
       if (this._check(TokenTypes.keywords.const)) {
         const _const = this._global_const_decl();
-        if (_const != null)
+        if (_const != null) {
           _const.attributes = attrs;
+        }
         this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
         return _const;
       }
       if (this._check(TokenTypes.keywords.struct)) {
         const _struct = this._struct_decl();
-        if (_struct != null)
+        if (_struct != null) {
           _struct.attributes = attrs;
+        }
         return _struct;
       }
       if (this._check(TokenTypes.keywords.fn)) {
         const _fn = this._function_decl();
-        if (_fn != null)
+        if (_fn != null) {
           _fn.attributes = attrs;
+        }
         return _fn;
       }
       return null;
     }
     _function_decl() {
-      if (!this._match(TokenTypes.keywords.fn))
+      if (!this._match(TokenTypes.keywords.fn)) {
         return null;
+      }
+      const startLine = this._currentLine;
       const name = this._consume(TokenTypes.tokens.ident, "Expected function name.").toString();
       this._consume(TokenTypes.tokens.paren_left, "Expected '(' for function arguments.");
       const args = [];
       if (!this._check(TokenTypes.tokens.paren_right)) {
         do {
-          if (this._check(TokenTypes.tokens.paren_right))
+          if (this._check(TokenTypes.tokens.paren_right)) {
             break;
+          }
           const argAttrs = this._attribute();
           const name2 = this._consume(TokenTypes.tokens.ident, "Expected argument name.").toString();
           this._consume(TokenTypes.tokens.colon, "Expected ':' for argument type.");
@@ -3253,19 +3555,22 @@ void main() {
       if (this._match(TokenTypes.tokens.arrow)) {
         const attrs = this._attribute();
         _return = this._type_decl();
-        if (_return != null)
+        if (_return != null) {
           _return.attributes = attrs;
+        }
       }
       const body = this._compound_statement();
-      return new Function(name, args, _return, body);
+      const endLine = this._currentLine;
+      return new Function(name, args, _return, body, startLine, endLine);
     }
     _compound_statement() {
       const statements = [];
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for block.");
       while (!this._check(TokenTypes.tokens.brace_right)) {
         const statement = this._statement();
-        if (statement !== null)
+        if (statement !== null) {
           statements.push(statement);
+        }
       }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' for block.");
       return statements;
@@ -3273,65 +3578,85 @@ void main() {
     _statement() {
       while (this._match(TokenTypes.tokens.semicolon) && !this._isAtEnd())
         ;
-      if (this._check(TokenTypes.keywords.if))
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
+      if (this._check(TokenTypes.keywords.if)) {
         return this._if_statement();
-      if (this._check(TokenTypes.keywords.switch))
+      }
+      if (this._check(TokenTypes.keywords.switch)) {
         return this._switch_statement();
-      if (this._check(TokenTypes.keywords.loop))
+      }
+      if (this._check(TokenTypes.keywords.loop)) {
         return this._loop_statement();
-      if (this._check(TokenTypes.keywords.for))
+      }
+      if (this._check(TokenTypes.keywords.for)) {
         return this._for_statement();
-      if (this._check(TokenTypes.keywords.while))
+      }
+      if (this._check(TokenTypes.keywords.while)) {
         return this._while_statement();
-      if (this._check(TokenTypes.keywords.continuing))
+      }
+      if (this._check(TokenTypes.keywords.continuing)) {
         return this._continuing_statement();
-      if (this._check(TokenTypes.keywords.static_assert))
+      }
+      if (this._check(TokenTypes.keywords.static_assert)) {
         return this._static_assert_statement();
-      if (this._check(TokenTypes.tokens.brace_left))
+      }
+      if (this._check(TokenTypes.tokens.brace_left)) {
         return this._compound_statement();
+      }
       let result = null;
-      if (this._check(TokenTypes.keywords.return))
+      if (this._check(TokenTypes.keywords.return)) {
         result = this._return_statement();
-      else if (this._check([
+      } else if (this._check([
         TokenTypes.keywords.var,
         TokenTypes.keywords.let,
         TokenTypes.keywords.const
-      ]))
+      ])) {
         result = this._variable_statement();
-      else if (this._match(TokenTypes.keywords.discard))
+      } else if (this._match(TokenTypes.keywords.discard)) {
         result = new Discard();
-      else if (this._match(TokenTypes.keywords.break))
+      } else if (this._match(TokenTypes.keywords.break)) {
         result = new Break();
-      else if (this._match(TokenTypes.keywords.continue))
+      } else if (this._match(TokenTypes.keywords.continue)) {
         result = new Continue();
-      else
+      } else {
         result = this._increment_decrement_statement() || this._func_call_statement() || this._assignment_statement();
-      if (result != null)
+      }
+      if (result != null) {
         this._consume(TokenTypes.tokens.semicolon, "Expected ';' after statement.");
+      }
       return result;
     }
     _static_assert_statement() {
-      if (!this._match(TokenTypes.keywords.static_assert))
+      if (!this._match(TokenTypes.keywords.static_assert)) {
         return null;
-      let expression = this._optional_paren_expression();
+      }
+      const expression = this._optional_paren_expression();
       return new StaticAssert(expression);
     }
     _while_statement() {
-      if (!this._match(TokenTypes.keywords.while))
+      if (!this._match(TokenTypes.keywords.while)) {
         return null;
-      let condition = this._optional_paren_expression();
+      }
+      const condition = this._optional_paren_expression();
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       const block = this._compound_statement();
       return new While(condition, block);
     }
     _continuing_statement() {
-      if (!this._match(TokenTypes.keywords.continuing))
+      if (!this._match(TokenTypes.keywords.continuing)) {
         return null;
+      }
       const block = this._compound_statement();
       return new Continuing(block);
     }
     _for_statement() {
-      if (!this._match(TokenTypes.keywords.for))
+      if (!this._match(TokenTypes.keywords.for)) {
         return null;
+      }
       this._consume(TokenTypes.tokens.paren_left, "Expected '('.");
       const init = !this._check(TokenTypes.tokens.semicolon) ? this._for_init() : null;
       this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
@@ -3339,6 +3664,9 @@ void main() {
       this._consume(TokenTypes.tokens.semicolon, "Expected ';'.");
       const increment = !this._check(TokenTypes.tokens.paren_right) ? this._for_increment() : null;
       this._consume(TokenTypes.tokens.paren_right, "Expected ')'.");
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       const body = this._compound_statement();
       return new For(init, condition, increment, body);
     }
@@ -3351,11 +3679,13 @@ void main() {
     _variable_statement() {
       if (this._check(TokenTypes.keywords.var)) {
         const _var = this._variable_decl();
-        if (_var === null)
+        if (_var === null) {
           throw this._error(this._peek(), "Variable declaration expected.");
+        }
         let value = null;
-        if (this._match(TokenTypes.tokens.equal))
+        if (this._match(TokenTypes.tokens.equal)) {
           value = this._short_circuit_or_expression();
+        }
         return new Var(_var.name, _var.type, _var.storage, _var.access, value);
       }
       if (this._match(TokenTypes.keywords.let)) {
@@ -3364,8 +3694,9 @@ void main() {
         if (this._match(TokenTypes.tokens.colon)) {
           const typeAttrs = this._attribute();
           type = this._type_decl();
-          if (type != null)
+          if (type != null) {
             type.attributes = typeAttrs;
+          }
         }
         this._consume(TokenTypes.tokens.equal, "Expected '=' for let.");
         const value = this._short_circuit_or_expression();
@@ -3377,8 +3708,9 @@ void main() {
         if (this._match(TokenTypes.tokens.colon)) {
           const typeAttrs = this._attribute();
           type = this._type_decl();
-          if (type != null)
+          if (type != null) {
             type.attributes = typeAttrs;
+          }
         }
         this._consume(TokenTypes.tokens.equal, "Expected '=' for const.");
         const value = this._short_circuit_or_expression();
@@ -3389,8 +3721,9 @@ void main() {
     _increment_decrement_statement() {
       const savedPos = this._current;
       const _var = this._unary_expression();
-      if (_var == null)
+      if (_var == null) {
         return null;
+      }
       if (!this._check(TokenTypes.increment_operators)) {
         this._current = savedPos;
         return null;
@@ -3400,20 +3733,24 @@ void main() {
     }
     _assignment_statement() {
       let _var = null;
-      if (this._check(TokenTypes.tokens.brace_right))
+      if (this._check(TokenTypes.tokens.brace_right)) {
         return null;
+      }
       let isUnderscore = this._match(TokenTypes.tokens.underscore);
-      if (!isUnderscore)
+      if (!isUnderscore) {
         _var = this._unary_expression();
-      if (!isUnderscore && _var == null)
+      }
+      if (!isUnderscore && _var == null) {
         return null;
+      }
       const type = this._consume(TokenTypes.assignment_operators, "Expected assignment operator.");
       const value = this._short_circuit_or_expression();
       return new Assign(AssignOperator.parse(type.lexeme), _var, value);
     }
     _func_call_statement() {
-      if (!this._check(TokenTypes.tokens.ident))
+      if (!this._check(TokenTypes.tokens.ident)) {
         return null;
+      }
       const savedPos = this._current;
       const name = this._consume(TokenTypes.tokens.ident, "Expected function name.");
       const args = this._argument_expression_list();
@@ -3424,8 +3761,12 @@ void main() {
       return new Call(name.lexeme, args);
     }
     _loop_statement() {
-      if (!this._match(TokenTypes.keywords.loop))
+      if (!this._match(TokenTypes.keywords.loop)) {
         return null;
+      }
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for loop.");
       const statements = [];
       let statement = this._statement();
@@ -3440,19 +3781,25 @@ void main() {
         statement = this._statement();
       }
       let continuing = null;
-      if (this._match(TokenTypes.keywords.continuing))
+      if (this._match(TokenTypes.keywords.continuing)) {
         continuing = this._compound_statement();
+      }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' for loop.");
       return new Loop(statements, continuing);
     }
     _switch_statement() {
-      if (!this._match(TokenTypes.keywords.switch))
+      if (!this._match(TokenTypes.keywords.switch)) {
         return null;
+      }
       const condition = this._optional_paren_expression();
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for switch.");
       const body = this._switch_body();
-      if (body == null || body.length == 0)
+      if (body == null || body.length == 0) {
         throw this._error(this._previous(), "Expected 'case' or 'default'.");
+      }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' for switch.");
       return new Switch(condition, body);
     }
@@ -3461,6 +3808,9 @@ void main() {
       if (this._match(TokenTypes.keywords.case)) {
         const selector = this._case_selectors();
         this._match(TokenTypes.tokens.colon);
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch case.");
         const body = this._case_body();
         this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch case.");
@@ -3468,6 +3818,9 @@ void main() {
       }
       if (this._match(TokenTypes.keywords.default)) {
         this._match(TokenTypes.tokens.colon);
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         this._consume(TokenTypes.tokens.brace_left, "Exected '{' for switch default.");
         const body = this._case_body();
         this._consume(TokenTypes.tokens.brace_right, "Exected '}' for switch default.");
@@ -3480,12 +3833,12 @@ void main() {
       return cases;
     }
     _case_selectors() {
-      var _a2, _b, _c, _d;
       const selectors = [
-        (_b = (_a2 = this._shift_expression()) === null || _a2 === void 0 ? void 0 : _a2.evaluate(this._context).toString()) !== null && _b !== void 0 ? _b : ""
+        this._shift_expression()
+        //?.evaluate(this._context).toString() ?? "",
       ];
       while (this._match(TokenTypes.tokens.comma)) {
-        selectors.push((_d = (_c = this._shift_expression()) === null || _c === void 0 ? void 0 : _c.evaluate(this._context).toString()) !== null && _d !== void 0 ? _d : "");
+        selectors.push(this._shift_expression());
       }
       return selectors;
     }
@@ -3495,28 +3848,41 @@ void main() {
         return [];
       }
       let statement = this._statement();
-      if (statement == null)
+      if (statement == null) {
         return [];
+      }
       if (!(statement instanceof Array)) {
         statement = [statement];
       }
       const nextStatement = this._case_body();
-      if (nextStatement.length == 0)
+      if (nextStatement.length == 0) {
         return statement;
+      }
       return [...statement, nextStatement[0]];
     }
     _if_statement() {
-      if (!this._match(TokenTypes.keywords.if))
+      if (!this._match(TokenTypes.keywords.if)) {
         return null;
+      }
       const condition = this._optional_paren_expression();
+      if (this._check(TokenTypes.tokens.attr)) {
+        this._attribute();
+      }
       const block = this._compound_statement();
       let elseif = [];
       if (this._match_elseif()) {
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         elseif = this._elseif_statement(elseif);
       }
       let _else = null;
-      if (this._match(TokenTypes.keywords.else))
+      if (this._match(TokenTypes.keywords.else)) {
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         _else = this._compound_statement();
+      }
       return new If(condition, block, elseif, _else);
     }
     _match_elseif() {
@@ -3532,13 +3898,17 @@ void main() {
       const block = this._compound_statement();
       elseif.push(new ElseIf(condition, block));
       if (this._match_elseif()) {
+        if (this._check(TokenTypes.tokens.attr)) {
+          this._attribute();
+        }
         this._elseif_statement(elseif);
       }
       return elseif;
     }
     _return_statement() {
-      if (!this._match(TokenTypes.keywords.return))
+      if (!this._match(TokenTypes.keywords.return)) {
         return null;
+      }
       const value = this._short_circuit_or_expression();
       return new Return(value);
     }
@@ -3636,25 +4006,29 @@ void main() {
     _singular_expression() {
       const expr = this._primary_expression();
       const p = this._postfix_expression();
-      if (p)
+      if (p) {
         expr.postfix = p;
+      }
       return expr;
     }
     _postfix_expression() {
       if (this._match(TokenTypes.tokens.bracket_left)) {
         const expr = this._short_circuit_or_expression();
         this._consume(TokenTypes.tokens.bracket_right, "Expected ']'.");
+        const arrayIndex = new ArrayIndex(expr);
         const p = this._postfix_expression();
-        if (p)
-          expr.postfix = p;
-        return expr;
+        if (p) {
+          arrayIndex.postfix = p;
+        }
+        return arrayIndex;
       }
       if (this._match(TokenTypes.tokens.period)) {
         const name = this._consume(TokenTypes.tokens.ident, "Expected member name.");
         const p = this._postfix_expression();
         const expr = new StringExpr(name.lexeme);
-        if (p)
+        if (p) {
           expr.postfix = p;
+        }
         return expr;
       }
       return null;
@@ -3705,12 +4079,14 @@ void main() {
       return new TypecastExpr(type, args);
     }
     _argument_expression_list() {
-      if (!this._match(TokenTypes.tokens.paren_left))
+      if (!this._match(TokenTypes.tokens.paren_left)) {
         return null;
+      }
       const args = [];
       do {
-        if (this._check(TokenTypes.tokens.paren_right))
+        if (this._check(TokenTypes.tokens.paren_right)) {
           break;
+        }
         const arg = this._short_circuit_or_expression();
         args.push(arg);
       } while (this._match(TokenTypes.tokens.comma));
@@ -3730,8 +4106,10 @@ void main() {
       return new GroupingExpr([expr]);
     }
     _struct_decl() {
-      if (!this._match(TokenTypes.keywords.struct))
+      if (!this._match(TokenTypes.keywords.struct)) {
         return null;
+      }
+      const startLine = this._currentLine;
       const name = this._consume(TokenTypes.tokens.ident, "Expected name for struct.").toString();
       this._consume(TokenTypes.tokens.brace_left, "Expected '{' for struct body.");
       const members = [];
@@ -3741,8 +4119,9 @@ void main() {
         this._consume(TokenTypes.tokens.colon, "Expected ':' for struct member type.");
         const typeAttrs = this._attribute();
         const memberType = this._type_decl();
-        if (memberType != null)
+        if (memberType != null) {
           memberType.attributes = typeAttrs;
+        }
         if (!this._check(TokenTypes.tokens.brace_right))
           this._consume(TokenTypes.tokens.comma, "Expected ',' for struct member.");
         else
@@ -3750,32 +4129,37 @@ void main() {
         members.push(new Member(memberName, memberType, memberAttrs));
       }
       this._consume(TokenTypes.tokens.brace_right, "Expected '}' after struct body.");
-      const structNode = new Struct(name, members);
+      const endLine = this._currentLine;
+      const structNode = new Struct(name, members, startLine, endLine);
       this._context.structs.set(name, structNode);
       return structNode;
     }
     _global_variable_decl() {
       const _var = this._variable_decl();
-      if (_var && this._match(TokenTypes.tokens.equal))
+      if (_var && this._match(TokenTypes.tokens.equal)) {
         _var.value = this._const_expression();
+      }
       return _var;
     }
     _override_variable_decl() {
       const _override = this._override_decl();
-      if (_override && this._match(TokenTypes.tokens.equal))
+      if (_override && this._match(TokenTypes.tokens.equal)) {
         _override.value = this._const_expression();
+      }
       return _override;
     }
     _global_const_decl() {
-      if (!this._match(TokenTypes.keywords.const))
+      if (!this._match(TokenTypes.keywords.const)) {
         return null;
+      }
       const name = this._consume(TokenTypes.tokens.ident, "Expected variable name");
       let type = null;
       if (this._match(TokenTypes.tokens.colon)) {
         const attrs = this._attribute();
         type = this._type_decl();
-        if (type != null)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       let value = null;
       if (this._match(TokenTypes.tokens.equal)) {
@@ -3798,15 +4182,17 @@ void main() {
       return c;
     }
     _global_let_decl() {
-      if (!this._match(TokenTypes.keywords.let))
+      if (!this._match(TokenTypes.keywords.let)) {
         return null;
+      }
       const name = this._consume(TokenTypes.tokens.ident, "Expected variable name");
       let type = null;
       if (this._match(TokenTypes.tokens.colon)) {
         const attrs = this._attribute();
         type = this._type_decl();
-        if (type != null)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       let value = null;
       if (this._match(TokenTypes.tokens.equal)) {
@@ -3815,23 +4201,26 @@ void main() {
       return new Let(name.toString(), type, "", "", value);
     }
     _const_expression() {
-      if (this._match(TokenTypes.const_literal))
+      if (this._match(TokenTypes.const_literal)) {
         return new StringExpr(this._previous().toString());
+      }
       const type = this._type_decl();
       this._consume(TokenTypes.tokens.paren_left, "Expected '('.");
       let args = [];
       while (!this._check(TokenTypes.tokens.paren_right)) {
         args.push(this._const_expression());
-        if (!this._check(TokenTypes.tokens.comma))
+        if (!this._check(TokenTypes.tokens.comma)) {
           break;
+        }
         this._advance();
       }
       this._consume(TokenTypes.tokens.paren_right, "Expected ')'.");
       return new CreateExpr(type, args);
     }
     _variable_decl() {
-      if (!this._match(TokenTypes.keywords.var))
+      if (!this._match(TokenTypes.keywords.var)) {
         return null;
+      }
       let storage = "";
       let access = "";
       if (this._match(TokenTypes.tokens.less_than)) {
@@ -3845,28 +4234,47 @@ void main() {
       if (this._match(TokenTypes.tokens.colon)) {
         const attrs = this._attribute();
         type = this._type_decl();
-        if (type != null)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       return new Var(name.toString(), type, storage, access, null);
     }
     _override_decl() {
-      if (!this._match(TokenTypes.keywords.override))
+      if (!this._match(TokenTypes.keywords.override)) {
         return null;
+      }
       const name = this._consume(TokenTypes.tokens.ident, "Expected variable name");
       let type = null;
       if (this._match(TokenTypes.tokens.colon)) {
         const attrs = this._attribute();
         type = this._type_decl();
-        if (type != null)
+        if (type != null) {
           type.attributes = attrs;
+        }
       }
       return new Override(name.toString(), type, null);
     }
+    _diagnostic() {
+      this._consume(TokenTypes.tokens.paren_left, "Expected '('");
+      const severity = this._consume(TokenTypes.tokens.ident, "Expected severity control name.");
+      this._consume(TokenTypes.tokens.comma, "Expected ','");
+      const rule = this._consume(TokenTypes.tokens.ident, "Expected diagnostic rule name.");
+      this._consume(TokenTypes.tokens.paren_right, "Expected ')'");
+      return new Diagnostic(severity.toString(), rule.toString());
+    }
     _enable_directive() {
       const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
       return new Enable(name.toString());
     }
+    _requires_directive() {
+      const extensions = [this._consume(TokenTypes.tokens.ident, "identity expected.").toString()];
+      while (this._match(TokenTypes.tokens.comma)) {
+        const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
+        extensions.push(name.toString());
+      }
+      return new Requires(extensions);
+    }
     _type_alias() {
       const name = this._consume(TokenTypes.tokens.ident, "identity expected.");
       this._consume(TokenTypes.tokens.equal, "Expected '=' for type alias.");
@@ -3901,8 +4309,9 @@ void main() {
         return new Type(type2.toString());
       }
       let type = this._texture_sampler_types();
-      if (type)
+      if (type) {
         return type;
+      }
       if (this._check(TokenTypes.template_types)) {
         let type2 = this._advance().toString();
         let format = null;
@@ -3910,8 +4319,9 @@ void main() {
         if (this._match(TokenTypes.tokens.less_than)) {
           format = this._type_decl();
           access = null;
-          if (this._match(TokenTypes.tokens.comma))
+          if (this._match(TokenTypes.tokens.comma)) {
             access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString();
+          }
           this._consume(TokenTypes.tokens.greater_than, "Expected '>' for type.");
         }
         return new TemplateType(type2, format, access);
@@ -3923,8 +4333,9 @@ void main() {
         this._consume(TokenTypes.tokens.comma, "Expected ',' for pointer.");
         const decl = this._type_decl();
         let access = null;
-        if (this._match(TokenTypes.tokens.comma))
+        if (this._match(TokenTypes.tokens.comma)) {
           access = this._consume(TokenTypes.access_mode, "Expected access_mode for pointer").toString();
+        }
         this._consume(TokenTypes.tokens.greater_than, "Expected '>' for pointer.");
         return new PointerType(pointer, storage.toString(), decl, access);
       }
@@ -3933,6 +4344,7 @@ void main() {
         let format = null;
         let countInt = -1;
         const array = this._previous();
+        let countNode = null;
         if (this._match(TokenTypes.tokens.less_than)) {
           format = this._type_decl();
           if (this._context.aliases.has(format.name)) {
@@ -3940,21 +4352,32 @@ void main() {
           }
           let count = "";
           if (this._match(TokenTypes.tokens.comma)) {
-            let c = this._shift_expression();
-            count = c.evaluate(this._context).toString();
+            countNode = this._shift_expression();
+            try {
+              count = countNode.evaluate(this._context).toString();
+              countNode = null;
+            } catch (e) {
+              count = "1";
+            }
           }
           this._consume(TokenTypes.tokens.greater_than, "Expected '>' for array.");
           countInt = count ? parseInt(count) : 0;
         }
-        return new ArrayType(array.toString(), attrs, format, countInt);
+        const arrayType = new ArrayType(array.toString(), attrs, format, countInt);
+        if (countNode) {
+          this._deferArrayCountEval.push({ arrayType, countNode });
+        }
+        return arrayType;
       }
       return null;
     }
     _texture_sampler_types() {
-      if (this._match(TokenTypes.sampler_type))
+      if (this._match(TokenTypes.sampler_type)) {
         return new SamplerType(this._previous().toString(), null, null);
-      if (this._match(TokenTypes.depth_texture_type))
+      }
+      if (this._match(TokenTypes.depth_texture_type)) {
         return new SamplerType(this._previous().toString(), null, null);
+      }
       if (this._match(TokenTypes.sampled_texture_type) || this._match(TokenTypes.multisampled_texture_type)) {
         const sampler = this._previous();
         this._consume(TokenTypes.tokens.less_than, "Expected '<' for sampler type.");
@@ -3994,31 +4417,9 @@ void main() {
         }
         attributes.push(attr);
       }
-      while (this._match(TokenTypes.tokens.attr_left)) {
-        if (!this._check(TokenTypes.tokens.attr_right)) {
-          do {
-            const name = this._consume(TokenTypes.attribute_name, "Expected attribute name");
-            const attr = new Attribute(name.toString(), null);
-            if (this._match(TokenTypes.tokens.paren_left)) {
-              attr.value = [
-                this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString()
-              ];
-              if (this._check(TokenTypes.tokens.comma)) {
-                this._advance();
-                do {
-                  const v = this._consume(TokenTypes.literal_or_ident, "Expected attribute value").toString();
-                  attr.value.push(v);
-                } while (this._match(TokenTypes.tokens.comma));
-              }
-              this._consume(TokenTypes.tokens.paren_right, "Expected ')'");
-            }
-            attributes.push(attr);
-          } while (this._match(TokenTypes.tokens.comma));
-        }
-        this._consume(TokenTypes.tokens.attr_right, "Expected ']]' after attribute declarations");
-      }
-      if (attributes.length == 0)
+      if (attributes.length == 0) {
         return null;
+      }
       return attributes;
     }
   };
@@ -4076,6 +4477,9 @@ void main() {
       super(name, attributes);
       this.members = [];
       this.align = 0;
+      this.startLine = -1;
+      this.endLine = -1;
+      this.inUse = false;
     }
     get isStruct() {
       return true;
@@ -4181,6 +4585,11 @@ void main() {
       this.stage = null;
       this.inputs = [];
       this.outputs = [];
+      this.resources = [];
+      this.startLine = -1;
+      this.endLine = -1;
+      this.inUse = false;
+      this.calls = /* @__PURE__ */ new Set();
       this.name = name;
       this.stage = stage;
     }
@@ -4200,6 +4609,14 @@ void main() {
       this.id = id;
     }
   };
+  var _FunctionResources = class {
+    constructor(node) {
+      this.resources = null;
+      this.inUse = false;
+      this.info = null;
+      this.node = node;
+    }
+  };
   var WgslReflect = class {
     constructor(code) {
       this.uniforms = [];
@@ -4210,7 +4627,9 @@ void main() {
       this.overrides = [];
       this.structs = [];
       this.entry = new EntryFunctions();
+      this.functions = [];
       this._types = /* @__PURE__ */ new Map();
+      this._functions = /* @__PURE__ */ new Map();
       if (code) {
         this.update(code);
       }
@@ -4221,14 +4640,20 @@ void main() {
     update(code) {
       const parser = new WgslParser();
       const ast = parser.parse(code);
+      for (const node of ast) {
+        if (node instanceof Function) {
+          this._functions.set(node.name, new _FunctionResources(node));
+        }
+      }
       for (const node of ast) {
         if (node instanceof Struct) {
           const info = this._getTypeInfo(node, null);
           if (info instanceof StructInfo) {
             this.structs.push(info);
           }
-          continue;
         }
+      }
+      for (const node of ast) {
         if (node instanceof Alias) {
           this.aliases.push(this._getAliasInfo(node));
           continue;
@@ -4287,8 +4712,15 @@ void main() {
           const fragmentStage = this._getAttribute(node, "fragment");
           const computeStage = this._getAttribute(node, "compute");
           const stage = vertexStage || fragmentStage || computeStage;
+          const fn = new FunctionInfo(node.name, stage === null || stage === void 0 ? void 0 : stage.name);
+          fn.startLine = node.startLine;
+          fn.endLine = node.endLine;
+          this.functions.push(fn);
+          this._functions.get(node.name).info = fn;
           if (stage) {
-            const fn = new FunctionInfo(node.name, stage.name);
+            this._functions.get(node.name).inUse = true;
+            fn.inUse = true;
+            fn.resources = this._findResources(node, !!stage);
             fn.inputs = this._getInputs(node.args);
             fn.outputs = this._getOutputs(node.returnType);
             this.entry[stage.name].push(fn);
@@ -4296,16 +4728,180 @@ void main() {
           continue;
         }
       }
+      for (const fn of this._functions.values()) {
+        if (fn.info) {
+          fn.info.inUse = fn.inUse;
+          this._addCalls(fn.node, fn.info.calls);
+        }
+      }
+      for (const u of this.uniforms) {
+        this._markStructsInUse(u.type);
+      }
+      for (const s of this.storage) {
+        this._markStructsInUse(s.type);
+      }
+    }
+    _markStructsInUse(type) {
+      if (type.isStruct) {
+        type.inUse = true;
+        for (const m of type.members) {
+          this._markStructsInUse(m.type);
+        }
+      } else if (type.isArray) {
+        this._markStructsInUse(type.format);
+      } else if (type.isTemplate) {
+        this._markStructsInUse(type.format);
+      } else {
+        const alias = this._getAlias(type.name);
+        if (alias) {
+          this._markStructsInUse(alias);
+        }
+      }
+    }
+    _addCalls(fn, calls) {
+      var _a2;
+      for (const call of fn.calls) {
+        const info = (_a2 = this._functions.get(call.name)) === null || _a2 === void 0 ? void 0 : _a2.info;
+        if (info) {
+          calls.add(info);
+        }
+      }
+    }
+    /// Find a resource by its group and binding.
+    findResource(group, binding) {
+      for (const u of this.uniforms) {
+        if (u.group == group && u.binding == binding) {
+          return u;
+        }
+      }
+      for (const s of this.storage) {
+        if (s.group == group && s.binding == binding) {
+          return s;
+        }
+      }
+      for (const t of this.textures) {
+        if (t.group == group && t.binding == binding) {
+          return t;
+        }
+      }
+      for (const s of this.samplers) {
+        if (s.group == group && s.binding == binding) {
+          return s;
+        }
+      }
+      return null;
+    }
+    _findResource(name) {
+      for (const u of this.uniforms) {
+        if (u.name == name) {
+          return u;
+        }
+      }
+      for (const s of this.storage) {
+        if (s.name == name) {
+          return s;
+        }
+      }
+      for (const t of this.textures) {
+        if (t.name == name) {
+          return t;
+        }
+      }
+      for (const s of this.samplers) {
+        if (s.name == name) {
+          return s;
+        }
+      }
+      return null;
+    }
+    _markStructsFromAST(type) {
+      const info = this._getTypeInfo(type, null);
+      this._markStructsInUse(info);
+    }
+    _findResources(fn, isEntry) {
+      const resources = [];
+      const self = this;
+      const varStack = [];
+      fn.search((node) => {
+        if (node instanceof _BlockStart) {
+          varStack.push({});
+        } else if (node instanceof _BlockEnd) {
+          varStack.pop();
+        } else if (node instanceof Var) {
+          const v = node;
+          if (isEntry && v.type !== null) {
+            this._markStructsFromAST(v.type);
+          }
+          if (varStack.length > 0) {
+            varStack[varStack.length - 1][v.name] = v;
+          }
+        } else if (node instanceof CreateExpr) {
+          const c = node;
+          if (isEntry && c.type !== null) {
+            this._markStructsFromAST(c.type);
+          }
+        } else if (node instanceof Let) {
+          const v = node;
+          if (isEntry && v.type !== null) {
+            this._markStructsFromAST(v.type);
+          }
+          if (varStack.length > 0) {
+            varStack[varStack.length - 1][v.name] = v;
+          }
+        } else if (node instanceof VariableExpr) {
+          const v = node;
+          if (varStack.length > 0) {
+            const varInfo2 = varStack[varStack.length - 1][v.name];
+            if (varInfo2) {
+              return;
+            }
+          }
+          const varInfo = self._findResource(v.name);
+          if (varInfo) {
+            resources.push(varInfo);
+          }
+        } else if (node instanceof CallExpr) {
+          const c = node;
+          const callFn = self._functions.get(c.name);
+          if (callFn) {
+            if (isEntry) {
+              callFn.inUse = true;
+            }
+            fn.calls.add(callFn.node);
+            if (callFn.resources === null) {
+              callFn.resources = self._findResources(callFn.node, isEntry);
+            }
+            resources.push(...callFn.resources);
+          }
+        } else if (node instanceof Call) {
+          const c = node;
+          const callFn = self._functions.get(c.name);
+          if (callFn) {
+            if (isEntry) {
+              callFn.inUse = true;
+            }
+            fn.calls.add(callFn.node);
+            if (callFn.resources === null) {
+              callFn.resources = self._findResources(callFn.node, isEntry);
+            }
+            resources.push(...callFn.resources);
+          }
+        }
+      });
+      return [...new Map(resources.map((r) => [r.name, r])).values()];
     }
     getBindGroups() {
       const groups = [];
       function _makeRoom(group, binding) {
-        if (group >= groups.length)
+        if (group >= groups.length) {
           groups.length = group + 1;
-        if (groups[group] === void 0)
+        }
+        if (groups[group] === void 0) {
           groups[group] = [];
-        if (binding >= groups[group].length)
+        }
+        if (binding >= groups[group].length) {
           groups[group].length = binding + 1;
+        }
       }
       for (const u of this.uniforms) {
         _makeRoom(u.group, u.binding);
@@ -4330,14 +4926,16 @@ void main() {
       return groups;
     }
     _getOutputs(type, outputs = void 0) {
-      if (outputs === void 0)
+      if (outputs === void 0) {
         outputs = [];
+      }
       if (type instanceof Struct) {
         this._getStructOutputs(type, outputs);
       } else {
         const output = this._getOutputInfo(type);
-        if (output !== null)
+        if (output !== null) {
           outputs.push(output);
+        }
       }
       return outputs;
     }
@@ -4367,15 +4965,17 @@ void main() {
       return null;
     }
     _getInputs(args, inputs = void 0) {
-      if (inputs === void 0)
+      if (inputs === void 0) {
         inputs = [];
+      }
       for (const arg of args) {
         if (arg.type instanceof Struct) {
           this._getStructInputs(arg.type, inputs);
         } else {
           const input = this._getInputInfo(arg);
-          if (input !== null)
+          if (input !== null) {
             inputs.push(input);
+          }
         }
       }
       return inputs;
@@ -4386,8 +4986,9 @@ void main() {
           this._getStructInputs(m.type, inputs);
         } else {
           const input = this._getInputInfo(m);
-          if (input !== null)
+          if (input !== null) {
             inputs.push(input);
+          }
         }
       }
     }
@@ -4420,8 +5021,9 @@ void main() {
     }
     _getAlias(name) {
       for (const a of this.aliases) {
-        if (a.name == name)
+        if (a.name == name) {
           return a.type;
+        }
       }
       return null;
     }
@@ -4445,6 +5047,8 @@ void main() {
       if (type instanceof Struct) {
         const s = type;
         const info2 = new StructInfo(s.name, attributes);
+        info2.startLine = s.startLine;
+        info2.endLine = s.endLine;
         for (const m of s.members) {
           const t = this._getTypeInfo(m.type, m.attributes);
           info2.members.push(new MemberInfo(m.name, t, m.attributes));
@@ -4497,8 +5101,9 @@ void main() {
       for (let mi = 0, ml = struct.members.length; mi < ml; ++mi) {
         const member = struct.members[mi];
         const sizeInfo = this._getTypeSize(member);
-        if (!sizeInfo)
+        if (!sizeInfo) {
           continue;
+        }
         (_a2 = this._getAlias(member.type.name)) !== null && _a2 !== void 0 ? _a2 : member.type;
         const align = sizeInfo.align;
         const size = sizeInfo.size;
@@ -4515,12 +5120,14 @@ void main() {
     }
     _getTypeSize(type) {
       var _a2;
-      if (type === null || type === void 0)
+      if (type === null || type === void 0) {
         return null;
+      }
       const explicitSize = this._getAttributeNum(type.attributes, "size", 0);
       const explicitAlign = this._getAttributeNum(type.attributes, "align", 0);
-      if (type instanceof MemberInfo)
+      if (type instanceof MemberInfo) {
         type = type.type;
+      }
       if (type instanceof TypeInfo) {
         const alias = this._getAlias(type.name);
         if (alias !== null) {
@@ -4553,8 +5160,9 @@ void main() {
         const N = arrayType.count;
         const stride = this._getAttributeNum((_a2 = type === null || type === void 0 ? void 0 : type.attributes) !== null && _a2 !== void 0 ? _a2 : null, "stride", this._roundUp(align, size));
         size = N * stride;
-        if (explicitSize)
+        if (explicitSize) {
           size = explicitSize;
+        }
         return new _TypeSize(Math.max(explicitAlign, align), Math.max(explicitSize, size));
       }
       if (type instanceof StructInfo) {
@@ -4591,18 +5199,21 @@ void main() {
     }
     _getAttribute(node, name) {
       const obj = node;
-      if (!obj || !obj["attributes"])
+      if (!obj || !obj["attributes"]) {
         return null;
+      }
       const attrs = obj["attributes"];
       for (let a of attrs) {
-        if (a.name == name)
+        if (a.name == name) {
           return a;
+        }
       }
       return null;
     }
     _getAttributeNum(attributes, name, defaultValue) {
-      if (attributes === null)
+      if (attributes === null) {
         return defaultValue;
+      }
       for (let a of attributes) {
         if (a.name == name) {
           let v = a !== null && a.value !== null ? a.value : defaultValue;
@@ -4662,10 +5273,10 @@ void main() {
     }
     for (const uniform of parsedWGSL.uniforms) {
       const members = [];
-      for (const member of uniform.type.members) {
+      for (const attribute of uniform.type?.members || []) {
         members.push({
-          name: member.name,
-          type: getType(member.type)
+          name: attribute.name,
+          type: getType(attribute.type)
         });
       }
       shaderLayout.bindings.push({
@@ -4685,7 +5296,7 @@ void main() {
         const type = getType(wgslAttribute.type);
         shaderLayout.attributes.push({
           name: wgslAttribute.name,
-          location: wgslAttribute.location,
+          location: Number(wgslAttribute.location),
           type
         });
       }