From 6b4983c2c9ebb42ba637a6d9280f59f46de14d38 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Tue, 21 Mar 2023 00:41:03 -0500
Subject: [PATCH 01/64] feat: AST types

---
 src/ast.ts | 108 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 src/ast.ts

diff --git a/src/ast.ts b/src/ast.ts
new file mode 100644
index 0000000..d56893e
--- /dev/null
+++ b/src/ast.ts
@@ -0,0 +1,108 @@
+export interface Node {}
+
+export interface Literal extends Node {
+  value: string | number | boolean
+}
+
+export interface Identifier extends Node {
+  value: string
+}
+
+export interface VariableDeclaration extends Node {
+  name: string
+  type: Node
+  value: Node | null
+  qualifiers: Node[]
+}
+
+export interface BlockStatement extends Node {
+  body: Node[]
+}
+
+export interface FunctionDeclaration extends Node {
+  name: string
+  type: Node | null
+  args: VariableDeclaration[]
+  body: BlockStatement
+}
+
+export interface CallExpression extends Node {
+  callee: Node
+  args: Node[]
+}
+
+export interface MemberExpression extends Node {
+  object: Node
+  property: Node
+}
+
+export interface ArrayExpression extends Node {
+  members: Node[]
+}
+
+export interface IfStatement extends Node {
+  test: Node
+  consequent: Node
+  alternate: Node | null
+}
+
+export interface WhileStatement extends Node {
+  test: Node
+  body: Node
+}
+
+export interface ForStatement extends Node {
+  init: Node | null
+  test: Node | null
+  update: Node | null
+  body: Node
+}
+
+export interface DoWhileStatement extends Node {
+  test: Node
+  body: Node
+}
+
+export interface SwitchCase extends Node {
+  test: Node | null
+  consequent: Node[]
+}
+
+export interface SwitchStatement extends Node {
+  discriminant: Node
+  cases: SwitchCase[]
+}
+
+export interface StructDeclaration extends Node {
+  name: string
+  members: VariableDeclaration[]
+}
+
+export interface ReturnStatement extends Node {
+  argument: Node | null
+}
+
+export interface UnaryExpression extends Node {
+  operator: string
+  argument: Node
+}
+
+export interface BinaryExpression extends Node {
+  operator: string
+  left: Node
+  right: Node
+}
+
+export interface TernaryExpression extends Node {
+  test: Node
+  consequent: Node
+  alternate: Node
+}
+
+export interface ContinueStatement extends Node {}
+
+export interface BreakStatement extends Node {}
+
+export interface ReturnStatement extends Node {}
+
+export interface DiscardStatement extends Node {}

From efaffe1a6b05aacd0c5c92fba389f3cda6fb7c68 Mon Sep 17 00:00:00 2001
From: Cody Bennett <23324155+CodyJasonBennett@users.noreply.github.com>
Date: Tue, 20 Jun 2023 04:26:54 -0500
Subject: [PATCH 02/64] refactor: narrow ReturnStatement

---
 src/ast.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index d56893e..37c70d0 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -79,7 +79,7 @@ export interface StructDeclaration extends Node {
 }
 
 export interface ReturnStatement extends Node {
-  argument: Node | null
+  argument: Literal | Identifier | UnaryExpression | null
 }
 
 export interface UnaryExpression extends Node {
@@ -103,6 +103,4 @@ export interface ContinueStatement extends Node {}
 
 export interface BreakStatement extends Node {}
 
-export interface ReturnStatement extends Node {}
-
 export interface DiscardStatement extends Node {}

From e8590f349bdaec4773b63d0f2c97588d422030dd Mon Sep 17 00:00:00 2001
From: Cody Bennett <23324155+CodyJasonBennett@users.noreply.github.com>
Date: Tue, 20 Jun 2023 20:46:01 -0500
Subject: [PATCH 03/64] feat: parser, type branding

---
 src/ast.ts    | 39 ++++++++++++++++++++++++++++++++-------
 src/parser.ts | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+), 7 deletions(-)
 create mode 100644 src/parser.ts

diff --git a/src/ast.ts b/src/ast.ts
index 37c70d0..9305020 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -1,14 +1,17 @@
 export interface Node {}
 
 export interface Literal extends Node {
+  __brand: 'Literal'
   value: string | number | boolean
 }
 
 export interface Identifier extends Node {
+  __brand: 'Identifier'
   value: string
 }
 
 export interface VariableDeclaration extends Node {
+  __brand: 'VariableDeclaration'
   name: string
   type: Node
   value: Node | null
@@ -16,10 +19,12 @@ export interface VariableDeclaration extends Node {
 }
 
 export interface BlockStatement extends Node {
+  __brand: 'BlockStatement'
   body: Node[]
 }
 
 export interface FunctionDeclaration extends Node {
+  __brand: 'FunctionDeclaration'
   name: string
   type: Node | null
   args: VariableDeclaration[]
@@ -27,31 +32,37 @@ export interface FunctionDeclaration extends Node {
 }
 
 export interface CallExpression extends Node {
+  __brand: 'CallExpression'
   callee: Node
   args: Node[]
 }
 
 export interface MemberExpression extends Node {
+  __brand: 'MemberExpression'
   object: Node
   property: Node
 }
 
 export interface ArrayExpression extends Node {
+  __brand: 'ArrayExpression'
   members: Node[]
 }
 
 export interface IfStatement extends Node {
+  __brand: 'IfStatement'
   test: Node
   consequent: Node
   alternate: Node | null
 }
 
 export interface WhileStatement extends Node {
+  __brand: 'WhileStatement'
   test: Node
   body: Node
 }
 
 export interface ForStatement extends Node {
+  __brand: 'ForStatement'
   init: Node | null
   test: Node | null
   update: Node | null
@@ -59,48 +70,62 @@ export interface ForStatement extends Node {
 }
 
 export interface DoWhileStatement extends Node {
+  __brand: 'DoWhileStatement'
   test: Node
   body: Node
 }
 
 export interface SwitchCase extends Node {
+  __brand: 'SwitchCase'
   test: Node | null
   consequent: Node[]
 }
 
 export interface SwitchStatement extends Node {
+  __brand: 'SwitchStatement'
   discriminant: Node
   cases: SwitchCase[]
 }
 
 export interface StructDeclaration extends Node {
+  __brand: 'StructDeclaration'
   name: string
   members: VariableDeclaration[]
 }
 
-export interface ReturnStatement extends Node {
-  argument: Literal | Identifier | UnaryExpression | null
-}
-
 export interface UnaryExpression extends Node {
+  __brand: 'UnaryExpression'
   operator: string
   argument: Node
 }
 
 export interface BinaryExpression extends Node {
+  __brand: 'BinaryExpression'
   operator: string
   left: Node
   right: Node
 }
 
 export interface TernaryExpression extends Node {
+  __brand: 'TernaryExpression'
   test: Node
   consequent: Node
   alternate: Node
 }
 
-export interface ContinueStatement extends Node {}
+export interface ReturnStatement extends Node {
+  __brand: 'ReturnStatement'
+  argument: Literal | Identifier | UnaryExpression | null
+}
 
-export interface BreakStatement extends Node {}
+export interface ContinueStatement extends Node {
+  __brand: 'ContinueStatement'
+}
 
-export interface DiscardStatement extends Node {}
+export interface BreakStatement extends Node {
+  __brand: 'BreakStatement'
+}
+
+export interface DiscardStatement extends Node {
+  __brand: 'DiscardStatement'
+}
diff --git a/src/parser.ts b/src/parser.ts
new file mode 100644
index 0000000..45ae382
--- /dev/null
+++ b/src/parser.ts
@@ -0,0 +1,50 @@
+import {
+  type Node,
+  type Literal,
+  type Identifier,
+  type VariableDeclaration,
+  type BlockStatement,
+  type FunctionDeclaration,
+  type CallExpression,
+  type MemberExpression,
+  type ArrayExpression,
+  type IfStatement,
+  type WhileStatement,
+  type ForStatement,
+  type DoWhileStatement,
+  type SwitchCase,
+  type SwitchStatement,
+  type StructDeclaration,
+  type UnaryExpression,
+  type BinaryExpression,
+  type TernaryExpression,
+  type ReturnStatement,
+  type ContinueStatement,
+  type BreakStatement,
+  type DiscardStatement,
+} from './ast'
+
+const isLiteral = (node: Node): node is Literal => (node as any).__brand === 'Literal'
+const isIdentifier = (node: Node): node is Identifier => (node as any).__brand === 'Identifier'
+const isVariableDeclaration = (node: Node): node is VariableDeclaration =>
+  (node as any).__brand === 'VariableDeclaration'
+const isBlockStatement = (node: Node): node is BlockStatement => (node as any).__brand === 'BlockStatement'
+const isFunctionDeclaration = (node: Node): node is FunctionDeclaration =>
+  (node as any).__brand === 'FunctionDeclaration'
+const isCallExpression = (node: Node): node is CallExpression => (node as any).__brand === 'CallExpression'
+const isMemberExpression = (node: Node): node is MemberExpression => (node as any).__brand === 'MemberExpression'
+const isArrayExpression = (node: Node): node is ArrayExpression => (node as any).__brand === 'ArrayExpression'
+const isIfStatement = (node: Node): node is IfStatement => (node as any).__brand === 'IfStatement'
+const isWhileStatement = (node: Node): node is WhileStatement => (node as any).__brand === 'WhileStatement'
+const isForStatement = (node: Node): node is ForStatement => (node as any).__brand === 'ForStatement'
+const isDoWhileStatement = (node: Node): node is DoWhileStatement => (node as any).__brand === 'DoWhileStatement'
+const isSwitchCase = (node: Node): node is SwitchCase => (node as any).__brand === 'SwitchCase'
+const isSwitchStatement = (node: Node): node is SwitchStatement => (node as any).__brand === 'SwitchStatement'
+const isStructDeclaration = (node: Node): node is StructDeclaration => (node as any).__brand === 'StructDeclaration'
+const isUnaryExpression = (node: Node): node is UnaryExpression => (node as any).__brand === 'UnaryExpression'
+const isBinaryExpression = (node: Node): node is BinaryExpression => (node as any).__brand === 'BinaryExpression'
+const isTernaryExpression = (node: Node): node is TernaryExpression => (node as any).__brand === 'TernaryExpression'
+const isReturnStatement = (node: Node): node is ReturnStatement => (node as any).__brand === 'ReturnStatement'
+const isContinueStatement = (node: Node): node is ContinueStatement => (node as any).__brand === 'ContinueStatement'
+const isBreakStatement = (node: Node): node is BreakStatement => (node as any).__brand === 'BreakStatement'
+const isDiscardStatement = (node: Node): node is DiscardStatement => (node as any).__brand === 'DiscardStatement'

From 6583245033aca2ed851caffd8bfee2e35b654a38 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 00:54:37 -0600
Subject: [PATCH 04/64] feat(parser): PoC reflection pass

---
 src/index.ts  |   2 +
 src/parser.ts | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++
 tsconfig.json |   2 +-
 3 files changed, 109 insertions(+), 1 deletion(-)

diff --git a/src/index.ts b/src/index.ts
index 5483538..0550f9e 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,3 +1,5 @@
+export * from './ast'
 export * from './constants'
 export * from './minifier'
+export * from './parser'
 export * from './tokenizer'
diff --git a/src/parser.ts b/src/parser.ts
index 45ae382..a6e35f0 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -23,6 +23,7 @@ import {
   type BreakStatement,
   type DiscardStatement,
 } from './ast'
+import { type Token, tokenize } from './tokenizer'
 
 const isLiteral = (node: Node): node is Literal => (node as any).__brand === 'Literal'
 const isIdentifier = (node: Node): node is Identifier => (node as any).__brand === 'Identifier'
@@ -48,3 +49,108 @@ const isReturnStatement = (node: Node): node is ReturnStatement => (node as any)
 const isContinueStatement = (node: Node): node is ContinueStatement => (node as any).__brand === 'ContinueStatement'
 const isBreakStatement = (node: Node): node is BreakStatement => (node as any).__brand === 'BreakStatement'
 const isDiscardStatement = (node: Node): node is DiscardStatement => (node as any).__brand === 'DiscardStatement'
+
+const isOpen = RegExp.prototype.test.bind(/^[\(\[\{]$/)
+const isClose = RegExp.prototype.test.bind(/^[\)\]\}]$/)
+
+function getScopeIndex(token: Token): number {
+  if (isOpen(token.value)) return 1
+  if (isClose(token.value)) return -1
+  return 0
+}
+
+/**
+ * Parses a string of GLSL or WGSL code into an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
+ */
+export function parse(code: string): Node[] {
+  // TODO: preserve
+  const tokens = tokenize(code).filter((token) => token.type !== 'whitespace' && token.type !== 'comment')
+  let i = 0
+
+  // TODO: this is GLSL-only, separate language constants
+  const isType = RegExp.prototype.test.bind(/^(void|bool|float|u?int|[ui]?vec\d|mat\d(x\d)?)$/)
+  const isStorage = RegExp.prototype.test.bind(/^(uniform|in|out|attribute|varying)$/)
+  const isQualifier = RegExp.prototype.test.bind(/^(centroid|flat|smooth)$/)
+
+  function getTokensUntil(value: string): Token[] {
+    const output: Token[] = []
+    let scopeIndex = 0
+
+    while (i < tokens.length) {
+      const token = tokens[i++]
+      output.push(token)
+
+      scopeIndex += getScopeIndex(token)
+      if (scopeIndex === 0 && token.value === value) break
+    }
+
+    return output
+  }
+
+  function parseBlock<T extends BlockStatement>(node: T): T {
+    if (tokens[i].value === '{') i++
+
+    let scopeIndex = 0
+
+    while (i < tokens.length) {
+      const token = tokens[i++]
+
+      scopeIndex += getScopeIndex(token)
+      if (scopeIndex < 0) break // skip }
+
+      let statement: Node | null = null
+
+      if (token.type === 'keyword') {
+        if (isQualifier(token.value) || isStorage(token.value) || isType(token.value) || token.value === 'const') {
+          if (tokens[i + 2]?.value === '(') {
+            const body = getTokensUntil('}')
+            statement = { __brand: 'FunctionDeclaration', body }
+          } else {
+            const qualifiers: string[] = []
+            while (tokens[i].type !== 'identifier') qualifiers.push(tokens[i++].value)
+            const type = qualifiers.pop()!
+
+            const body = getTokensUntil(';')
+            const name = body.shift()!.value
+            body.pop() // skip ;
+
+            let value = null
+            if (body.length) {
+              // TODO: parse expression
+            }
+
+            statement = { __brand: 'VariableDeclaration', name, type, value, qualifiers } satisfies VariableDeclaration
+          }
+        } else if (token.value === 'return') {
+          const body = getTokensUntil(';')
+          statement = { __brand: 'ReturnStatement', body }
+        } else if (token.value === 'if') {
+          const body = getTokensUntil('}')
+          statement = { __brand: 'IfStatement', body }
+        } else if (token.value === 'for') {
+          const body = getTokensUntil('}')
+          statement = { __brand: 'ForStatement', body }
+        }
+      }
+
+      if (statement) node.body.push(statement)
+    }
+
+    return node
+  }
+
+  const program: BlockStatement = { __brand: 'BlockStatement', body: [] }
+  parseBlock(program)
+
+  return program.body
+}
+
+const glsl = /* glsl */ `
+  flat in mat4 test;
+
+  if (true) {
+    gl_FragColor = vec4(1, 0, 0, 1); // red
+  }
+`
+
+console.log(parse(glsl))
diff --git a/tsconfig.json b/tsconfig.json
index d98d302..9da44d9 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,7 +3,7 @@
     "outDir": "dist",
     "target": "esnext",
     "module": "esnext",
-    "lib": ["esnext", "dom"],
+    "lib": ["esnext"],
     "moduleResolution": "node",
     "strict": true,
     "pretty": true,

From aa29f5d98b8a0c8b107608e76cf854ec1a9c4ffb Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 00:56:11 -0600
Subject: [PATCH 05/64] chore: lint

---
 tsconfig.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tsconfig.json b/tsconfig.json
index 9da44d9..d98d302 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,7 +3,7 @@
     "outDir": "dist",
     "target": "esnext",
     "module": "esnext",
-    "lib": ["esnext"],
+    "lib": ["esnext", "dom"],
     "moduleResolution": "node",
     "strict": true,
     "pretty": true,

From 4b5e049e4ec5e61916297a4fb1b8476abd3aefd4 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 00:56:49 -0600
Subject: [PATCH 06/64] refactor: Node => AST for TS

---
 src/ast.ts    | 106 +++++++++++++++++++++++++-------------------------
 src/parser.ts |  50 ++++++++++++------------
 2 files changed, 78 insertions(+), 78 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 9305020..66b8f17 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -1,131 +1,131 @@
-export interface Node {}
+export interface AST {}
 
-export interface Literal extends Node {
+export interface Literal extends AST {
   __brand: 'Literal'
   value: string | number | boolean
 }
 
-export interface Identifier extends Node {
+export interface Identifier extends AST {
   __brand: 'Identifier'
   value: string
 }
 
-export interface VariableDeclaration extends Node {
+export interface VariableDeclaration extends AST {
   __brand: 'VariableDeclaration'
   name: string
-  type: Node
-  value: Node | null
-  qualifiers: Node[]
+  type: AST
+  value: AST | null
+  qualifiers: AST[]
 }
 
-export interface BlockStatement extends Node {
+export interface BlockStatement extends AST {
   __brand: 'BlockStatement'
-  body: Node[]
+  body: AST[]
 }
 
-export interface FunctionDeclaration extends Node {
+export interface FunctionDeclaration extends AST {
   __brand: 'FunctionDeclaration'
   name: string
-  type: Node | null
+  type: AST | null
   args: VariableDeclaration[]
   body: BlockStatement
 }
 
-export interface CallExpression extends Node {
+export interface CallExpression extends AST {
   __brand: 'CallExpression'
-  callee: Node
-  args: Node[]
+  callee: AST
+  args: AST[]
 }
 
-export interface MemberExpression extends Node {
+export interface MemberExpression extends AST {
   __brand: 'MemberExpression'
-  object: Node
-  property: Node
+  object: AST
+  property: AST
 }
 
-export interface ArrayExpression extends Node {
+export interface ArrayExpression extends AST {
   __brand: 'ArrayExpression'
-  members: Node[]
+  members: AST[]
 }
 
-export interface IfStatement extends Node {
+export interface IfStatement extends AST {
   __brand: 'IfStatement'
-  test: Node
-  consequent: Node
-  alternate: Node | null
+  test: AST
+  consequent: AST
+  alternate: AST | null
 }
 
-export interface WhileStatement extends Node {
+export interface WhileStatement extends AST {
   __brand: 'WhileStatement'
-  test: Node
-  body: Node
+  test: AST
+  body: AST
 }
 
-export interface ForStatement extends Node {
+export interface ForStatement extends AST {
   __brand: 'ForStatement'
-  init: Node | null
-  test: Node | null
-  update: Node | null
-  body: Node
+  init: AST | null
+  test: AST | null
+  update: AST | null
+  body: AST
 }
 
-export interface DoWhileStatement extends Node {
+export interface DoWhileStatement extends AST {
   __brand: 'DoWhileStatement'
-  test: Node
-  body: Node
+  test: AST
+  body: AST
 }
 
-export interface SwitchCase extends Node {
+export interface SwitchCase extends AST {
   __brand: 'SwitchCase'
-  test: Node | null
-  consequent: Node[]
+  test: AST | null
+  consequent: AST[]
 }
 
-export interface SwitchStatement extends Node {
+export interface SwitchStatement extends AST {
   __brand: 'SwitchStatement'
-  discriminant: Node
+  discriminant: AST
   cases: SwitchCase[]
 }
 
-export interface StructDeclaration extends Node {
+export interface StructDeclaration extends AST {
   __brand: 'StructDeclaration'
   name: string
   members: VariableDeclaration[]
 }
 
-export interface UnaryExpression extends Node {
+export interface UnaryExpression extends AST {
   __brand: 'UnaryExpression'
   operator: string
-  argument: Node
+  argument: AST
 }
 
-export interface BinaryExpression extends Node {
+export interface BinaryExpression extends AST {
   __brand: 'BinaryExpression'
   operator: string
-  left: Node
-  right: Node
+  left: AST
+  right: AST
 }
 
-export interface TernaryExpression extends Node {
+export interface TernaryExpression extends AST {
   __brand: 'TernaryExpression'
-  test: Node
-  consequent: Node
-  alternate: Node
+  test: AST
+  consequent: AST
+  alternate: AST
 }
 
-export interface ReturnStatement extends Node {
+export interface ReturnStatement extends AST {
   __brand: 'ReturnStatement'
   argument: Literal | Identifier | UnaryExpression | null
 }
 
-export interface ContinueStatement extends Node {
+export interface ContinueStatement extends AST {
   __brand: 'ContinueStatement'
 }
 
-export interface BreakStatement extends Node {
+export interface BreakStatement extends AST {
   __brand: 'BreakStatement'
 }
 
-export interface DiscardStatement extends Node {
+export interface DiscardStatement extends AST {
   __brand: 'DiscardStatement'
 }
diff --git a/src/parser.ts b/src/parser.ts
index a6e35f0..691782c 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,5 +1,5 @@
 import {
-  type Node,
+  type AST,
   type Literal,
   type Identifier,
   type VariableDeclaration,
@@ -25,30 +25,30 @@ import {
 } from './ast'
 import { type Token, tokenize } from './tokenizer'
 
-const isLiteral = (node: Node): node is Literal => (node as any).__brand === 'Literal'
-const isIdentifier = (node: Node): node is Identifier => (node as any).__brand === 'Identifier'
-const isVariableDeclaration = (node: Node): node is VariableDeclaration =>
+const isLiteral = (node: AST): node is Literal => (node as any).__brand === 'Literal'
+const isIdentifier = (node: AST): node is Identifier => (node as any).__brand === 'Identifier'
+const isVariableDeclaration = (node: AST): node is VariableDeclaration =>
   (node as any).__brand === 'VariableDeclaration'
-const isBlockStatement = (node: Node): node is BlockStatement => (node as any).__brand === 'BlockStatement'
-const isFunctionDeclaration = (node: Node): node is FunctionDeclaration =>
+const isBlockStatement = (node: AST): node is BlockStatement => (node as any).__brand === 'BlockStatement'
+const isFunctionDeclaration = (node: AST): node is FunctionDeclaration =>
   (node as any).__brand === 'FunctionDeclaration'
-const isCallExpression = (node: Node): node is CallExpression => (node as any).__brand === 'CallExpression'
-const isMemberExpression = (node: Node): node is MemberExpression => (node as any).__brand === 'MemberExpression'
-const isArrayExpression = (node: Node): node is ArrayExpression => (node as any).__brand === 'ArrayExpression'
-const isIfStatement = (node: Node): node is IfStatement => (node as any).__brand === 'IfStatement'
-const isWhileStatement = (node: Node): node is WhileStatement => (node as any).__brand === 'WhileStatement'
-const isForStatement = (node: Node): node is ForStatement => (node as any).__brand === 'ForStatement'
-const isDoWhileStatement = (node: Node): node is DoWhileStatement => (node as any).__brand === 'DoWhileStatement'
-const isSwitchCase = (node: Node): node is SwitchCase => (node as any).__brand === 'SwitchCase'
-const isSwitchStatement = (node: Node): node is SwitchStatement => (node as any).__brand === 'SwitchStatement'
-const isStructDeclaration = (node: Node): node is StructDeclaration => (node as any).__brand === 'StructDeclaration'
-const isUnaryExpression = (node: Node): node is UnaryExpression => (node as any).__brand === 'UnaryExpression'
-const isBinaryExpression = (node: Node): node is BinaryExpression => (node as any).__brand === 'BinaryExpression'
-const isTernaryExpression = (node: Node): node is TernaryExpression => (node as any).__brand === 'TernaryExpression'
-const isReturnStatement = (node: Node): node is ReturnStatement => (node as any).__brand === 'ReturnStatement'
-const isContinueStatement = (node: Node): node is ContinueStatement => (node as any).__brand === 'ContinueStatement'
-const isBreakStatement = (node: Node): node is BreakStatement => (node as any).__brand === 'BreakStatement'
-const isDiscardStatement = (node: Node): node is DiscardStatement => (node as any).__brand === 'DiscardStatement'
+const isCallExpression = (node: AST): node is CallExpression => (node as any).__brand === 'CallExpression'
+const isMemberExpression = (node: AST): node is MemberExpression => (node as any).__brand === 'MemberExpression'
+const isArrayExpression = (node: AST): node is ArrayExpression => (node as any).__brand === 'ArrayExpression'
+const isIfStatement = (node: AST): node is IfStatement => (node as any).__brand === 'IfStatement'
+const isWhileStatement = (node: AST): node is WhileStatement => (node as any).__brand === 'WhileStatement'
+const isForStatement = (node: AST): node is ForStatement => (node as any).__brand === 'ForStatement'
+const isDoWhileStatement = (node: AST): node is DoWhileStatement => (node as any).__brand === 'DoWhileStatement'
+const isSwitchCase = (node: AST): node is SwitchCase => (node as any).__brand === 'SwitchCase'
+const isSwitchStatement = (node: AST): node is SwitchStatement => (node as any).__brand === 'SwitchStatement'
+const isStructDeclaration = (node: AST): node is StructDeclaration => (node as any).__brand === 'StructDeclaration'
+const isUnaryExpression = (node: AST): node is UnaryExpression => (node as any).__brand === 'UnaryExpression'
+const isBinaryExpression = (node: AST): node is BinaryExpression => (node as any).__brand === 'BinaryExpression'
+const isTernaryExpression = (node: AST): node is TernaryExpression => (node as any).__brand === 'TernaryExpression'
+const isReturnStatement = (node: AST): node is ReturnStatement => (node as any).__brand === 'ReturnStatement'
+const isContinueStatement = (node: AST): node is ContinueStatement => (node as any).__brand === 'ContinueStatement'
+const isBreakStatement = (node: AST): node is BreakStatement => (node as any).__brand === 'BreakStatement'
+const isDiscardStatement = (node: AST): node is DiscardStatement => (node as any).__brand === 'DiscardStatement'
 
 const isOpen = RegExp.prototype.test.bind(/^[\(\[\{]$/)
 const isClose = RegExp.prototype.test.bind(/^[\)\]\}]$/)
@@ -62,7 +62,7 @@ function getScopeIndex(token: Token): number {
 /**
  * Parses a string of GLSL or WGSL code into an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
  */
-export function parse(code: string): Node[] {
+export function parse(code: string): AST[] {
   // TODO: preserve
   const tokens = tokenize(code).filter((token) => token.type !== 'whitespace' && token.type !== 'comment')
   let i = 0
@@ -98,7 +98,7 @@ export function parse(code: string): Node[] {
       scopeIndex += getScopeIndex(token)
       if (scopeIndex < 0) break // skip }
 
-      let statement: Node | null = null
+      let statement: AST | null = null
 
       if (token.type === 'keyword') {
         if (isQualifier(token.value) || isStorage(token.value) || isType(token.value) || token.value === 'const') {

From 790523c4c22e47ed4efec8cf0d21f6f50a7735e3 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 00:59:06 -0600
Subject: [PATCH 07/64] chore: inline bitmap sweep

---
 src/parser.ts | 17 +++--------------
 1 file changed, 3 insertions(+), 14 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 691782c..120b882 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -53,12 +53,6 @@ const isDiscardStatement = (node: AST): node is DiscardStatement => (node as any
 const isOpen = RegExp.prototype.test.bind(/^[\(\[\{]$/)
 const isClose = RegExp.prototype.test.bind(/^[\)\]\}]$/)
 
-function getScopeIndex(token: Token): number {
-  if (isOpen(token.value)) return 1
-  if (isClose(token.value)) return -1
-  return 0
-}
-
 /**
  * Parses a string of GLSL or WGSL code into an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
  */
@@ -80,7 +74,9 @@ export function parse(code: string): AST[] {
       const token = tokens[i++]
       output.push(token)
 
-      scopeIndex += getScopeIndex(token)
+      if (isOpen(token.value)) scopeIndex++
+      if (isClose(token.value)) scopeIndex--
+
       if (scopeIndex === 0 && token.value === value) break
     }
 
@@ -88,16 +84,9 @@ export function parse(code: string): AST[] {
   }
 
   function parseBlock<T extends BlockStatement>(node: T): T {
-    if (tokens[i].value === '{') i++
-
-    let scopeIndex = 0
-
     while (i < tokens.length) {
       const token = tokens[i++]
 
-      scopeIndex += getScopeIndex(token)
-      if (scopeIndex < 0) break // skip }
-
       let statement: AST | null = null
 
       if (token.type === 'keyword') {

From 80a15b777037abd4d0540ddbdde5f9d59f8f5395 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 01:41:26 -0600
Subject: [PATCH 08/64] refactor: use classes for AST

---
 src/ast.ts    | 175 ++++++++++++++++++++++++--------------------------
 src/parser.ts |  62 ++++--------------
 2 files changed, 98 insertions(+), 139 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 66b8f17..26a8d56 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -1,131 +1,126 @@
-export interface AST {}
+export abstract class AST {}
 
-export interface Literal extends AST {
-  __brand: 'Literal'
-  value: string | number | boolean
+export class Literal extends AST {
+  constructor(public value: string | number | boolean) {
+    super()
+  }
 }
 
-export interface Identifier extends AST {
-  __brand: 'Identifier'
-  value: string
+export class Identifier extends AST {
+  constructor(public value: string) {
+    super()
+  }
 }
 
-export interface VariableDeclaration extends AST {
-  __brand: 'VariableDeclaration'
-  name: string
-  type: AST
-  value: AST | null
-  qualifiers: AST[]
+export class VariableDeclaration extends AST {
+  constructor(public name: string, public type: AST, public value: AST | null, public qualifiers: AST[]) {
+    super()
+  }
 }
 
-export interface BlockStatement extends AST {
-  __brand: 'BlockStatement'
-  body: AST[]
+export class BlockStatement extends AST {
+  constructor(public body: AST[]) {
+    super()
+  }
 }
 
-export interface FunctionDeclaration extends AST {
-  __brand: 'FunctionDeclaration'
-  name: string
-  type: AST | null
-  args: VariableDeclaration[]
-  body: BlockStatement
+export class FunctionDeclaration extends AST {
+  constructor(
+    public name: string,
+    public type: AST | null,
+    public args: VariableDeclaration[],
+    public body: BlockStatement,
+  ) {
+    super()
+  }
 }
 
-export interface CallExpression extends AST {
-  __brand: 'CallExpression'
-  callee: AST
-  args: AST[]
+export class CallExpression extends AST {
+  constructor(public callee: AST, public args: AST[]) {
+    super()
+  }
 }
 
-export interface MemberExpression extends AST {
-  __brand: 'MemberExpression'
-  object: AST
-  property: AST
+export class MemberExpression extends AST {
+  constructor(public object: AST, public property: AST) {
+    super()
+  }
 }
 
-export interface ArrayExpression extends AST {
-  __brand: 'ArrayExpression'
-  members: AST[]
+export class ArrayExpression extends AST {
+  constructor(public members: AST[]) {
+    super()
+  }
 }
 
-export interface IfStatement extends AST {
-  __brand: 'IfStatement'
-  test: AST
-  consequent: AST
-  alternate: AST | null
+export class IfStatement extends AST {
+  constructor(public test: AST, public consequent: AST, public alternate: AST | null) {
+    super()
+  }
 }
 
-export interface WhileStatement extends AST {
-  __brand: 'WhileStatement'
-  test: AST
-  body: AST
+export class WhileStatement extends AST {
+  constructor(public test: AST, public body: AST) {
+    super()
+  }
 }
 
-export interface ForStatement extends AST {
-  __brand: 'ForStatement'
-  init: AST | null
-  test: AST | null
-  update: AST | null
-  body: AST
+export class ForStatement extends AST {
+  constructor(public init: AST | null, public test: AST | null, public update: AST | null, public body: AST) {
+    super()
+  }
 }
 
-export interface DoWhileStatement extends AST {
-  __brand: 'DoWhileStatement'
-  test: AST
-  body: AST
+export class DoWhileStatement extends AST {
+  constructor(public test: AST, public body: AST) {
+    super()
+  }
 }
 
-export interface SwitchCase extends AST {
-  __brand: 'SwitchCase'
-  test: AST | null
-  consequent: AST[]
+export class SwitchCase extends AST {
+  constructor(public test: AST | null, public consequent: AST[]) {
+    super()
+  }
 }
 
-export interface SwitchStatement extends AST {
-  __brand: 'SwitchStatement'
-  discriminant: AST
-  cases: SwitchCase[]
+export class SwitchStatement extends AST {
+  constructor(public discriminant: AST, public cases: SwitchCase[]) {
+    super()
+  }
 }
 
-export interface StructDeclaration extends AST {
-  __brand: 'StructDeclaration'
-  name: string
-  members: VariableDeclaration[]
+export class StructDeclaration extends AST {
+  constructor(public name: string, public members: VariableDeclaration[]) {
+    super()
+  }
 }
 
-export interface UnaryExpression extends AST {
-  __brand: 'UnaryExpression'
-  operator: string
-  argument: AST
+export class UnaryExpression extends AST {
+  constructor(public operator: string, public argument: AST) {
+    super()
+  }
 }
 
-export interface BinaryExpression extends AST {
-  __brand: 'BinaryExpression'
-  operator: string
-  left: AST
-  right: AST
+export class BinaryExpression extends AST {
+  constructor(public operator: string, public left: AST, public right: AST) {
+    super()
+  }
 }
 
-export interface TernaryExpression extends AST {
-  __brand: 'TernaryExpression'
-  test: AST
-  consequent: AST
-  alternate: AST
+export class TernaryExpression extends AST {
+  constructor(public test: AST, public consequent: AST, public alternate: AST) {
+    super()
+  }
 }
 
-export interface ReturnStatement extends AST {
-  __brand: 'ReturnStatement'
-  argument: Literal | Identifier | UnaryExpression | null
+export class ReturnStatement extends AST {
+  constructor(public argument: Literal | Identifier | UnaryExpression | null) {
+    super()
+  }
 }
 
-export interface ContinueStatement extends AST {
-  __brand: 'ContinueStatement'
-}
+export class ContinueStatement extends AST {}
 
-export interface BreakStatement extends AST {
-  __brand: 'BreakStatement'
-}
+export class BreakStatement extends AST {}
 
-export interface DiscardStatement extends AST {
-  __brand: 'DiscardStatement'
-}
+export class DiscardStatement extends AST {}
diff --git a/src/parser.ts b/src/parser.ts
index 120b882..8e91357 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,55 +1,13 @@
 import {
   type AST,
-  type Literal,
-  type Identifier,
-  type VariableDeclaration,
-  type BlockStatement,
-  type FunctionDeclaration,
-  type CallExpression,
-  type MemberExpression,
-  type ArrayExpression,
-  type IfStatement,
-  type WhileStatement,
-  type ForStatement,
-  type DoWhileStatement,
-  type SwitchCase,
-  type SwitchStatement,
-  type StructDeclaration,
-  type UnaryExpression,
-  type BinaryExpression,
-  type TernaryExpression,
-  type ReturnStatement,
-  type ContinueStatement,
-  type BreakStatement,
-  type DiscardStatement,
+  BlockStatement,
+  VariableDeclaration,
+  ContinueStatement,
+  BreakStatement,
+  DiscardStatement,
 } from './ast'
 import { type Token, tokenize } from './tokenizer'
 
-const isLiteral = (node: AST): node is Literal => (node as any).__brand === 'Literal'
-const isIdentifier = (node: AST): node is Identifier => (node as any).__brand === 'Identifier'
-const isVariableDeclaration = (node: AST): node is VariableDeclaration =>
-  (node as any).__brand === 'VariableDeclaration'
-const isBlockStatement = (node: AST): node is BlockStatement => (node as any).__brand === 'BlockStatement'
-const isFunctionDeclaration = (node: AST): node is FunctionDeclaration =>
-  (node as any).__brand === 'FunctionDeclaration'
-const isCallExpression = (node: AST): node is CallExpression => (node as any).__brand === 'CallExpression'
-const isMemberExpression = (node: AST): node is MemberExpression => (node as any).__brand === 'MemberExpression'
-const isArrayExpression = (node: AST): node is ArrayExpression => (node as any).__brand === 'ArrayExpression'
-const isIfStatement = (node: AST): node is IfStatement => (node as any).__brand === 'IfStatement'
-const isWhileStatement = (node: AST): node is WhileStatement => (node as any).__brand === 'WhileStatement'
-const isForStatement = (node: AST): node is ForStatement => (node as any).__brand === 'ForStatement'
-const isDoWhileStatement = (node: AST): node is DoWhileStatement => (node as any).__brand === 'DoWhileStatement'
-const isSwitchCase = (node: AST): node is SwitchCase => (node as any).__brand === 'SwitchCase'
-const isSwitchStatement = (node: AST): node is SwitchStatement => (node as any).__brand === 'SwitchStatement'
-const isStructDeclaration = (node: AST): node is StructDeclaration => (node as any).__brand === 'StructDeclaration'
-const isUnaryExpression = (node: AST): node is UnaryExpression => (node as any).__brand === 'UnaryExpression'
-const isBinaryExpression = (node: AST): node is BinaryExpression => (node as any).__brand === 'BinaryExpression'
-const isTernaryExpression = (node: AST): node is TernaryExpression => (node as any).__brand === 'TernaryExpression'
-const isReturnStatement = (node: AST): node is ReturnStatement => (node as any).__brand === 'ReturnStatement'
-const isContinueStatement = (node: AST): node is ContinueStatement => (node as any).__brand === 'ContinueStatement'
-const isBreakStatement = (node: AST): node is BreakStatement => (node as any).__brand === 'BreakStatement'
-const isDiscardStatement = (node: AST): node is DiscardStatement => (node as any).__brand === 'DiscardStatement'
-
 const isOpen = RegExp.prototype.test.bind(/^[\(\[\{]$/)
 const isClose = RegExp.prototype.test.bind(/^[\)\]\}]$/)
 
@@ -108,8 +66,14 @@ export function parse(code: string): AST[] {
               // TODO: parse expression
             }
 
-            statement = { __brand: 'VariableDeclaration', name, type, value, qualifiers } satisfies VariableDeclaration
+            statement = new VariableDeclaration(name, type, value, qualifiers)
           }
+        } else if (token.value === 'continue') {
+          statement = new ContinueStatement()
+        } else if (token.value === 'break') {
+          statement = new BreakStatement()
+        } else if (token.value === 'discard') {
+          statement = new DiscardStatement()
         } else if (token.value === 'return') {
           const body = getTokensUntil(';')
           statement = { __brand: 'ReturnStatement', body }
@@ -128,7 +92,7 @@ export function parse(code: string): AST[] {
     return node
   }
 
-  const program: BlockStatement = { __brand: 'BlockStatement', body: [] }
+  const program = new BlockStatement([])
   parseBlock(program)
 
   return program.body

From ba9bb970524428fc11af32e8d63c12e7d9d165ca Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 02:01:22 -0600
Subject: [PATCH 09/64] fix: harden qualifiers

---
 src/parser.ts | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 8e91357..18cc944 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -20,9 +20,8 @@ export function parse(code: string): AST[] {
   let i = 0
 
   // TODO: this is GLSL-only, separate language constants
-  const isType = RegExp.prototype.test.bind(/^(void|bool|float|u?int|[ui]?vec\d|mat\d(x\d)?)$/)
-  const isStorage = RegExp.prototype.test.bind(/^(uniform|in|out|attribute|varying)$/)
-  const isQualifier = RegExp.prototype.test.bind(/^(centroid|flat|smooth)$/)
+  const isType = RegExp.prototype.test.bind(/^(void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?)$/)
+  const isQualifier = RegExp.prototype.test.bind(/^(in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp)$/)
 
   function getTokensUntil(value: string): Token[] {
     const output: Token[] = []
@@ -48,7 +47,7 @@ export function parse(code: string): AST[] {
       let statement: AST | null = null
 
       if (token.type === 'keyword') {
-        if (isQualifier(token.value) || isStorage(token.value) || isType(token.value) || token.value === 'const') {
+        if (isQualifier(token.value) || isType(token.value) || token.value === 'const' || token.value === 'uniform') {
           if (tokens[i + 2]?.value === '(') {
             const body = getTokensUntil('}')
             statement = { __brand: 'FunctionDeclaration', body }
@@ -106,4 +105,4 @@ const glsl = /* glsl */ `
   }
 `
 
-console.log(parse(glsl))
+console.log(...parse(glsl))

From 68d0908e24b9678338f7addaa6d6b9374b2fc307 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 02:52:46 -0600
Subject: [PATCH 10/64] refactor: more basic parsing of methods, block
 statements

---
 src/parser.ts | 65 +++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 58 insertions(+), 7 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 18cc944..8494519 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,10 +1,14 @@
 import {
   type AST,
   BlockStatement,
+  FunctionDeclaration,
   VariableDeclaration,
   ContinueStatement,
   BreakStatement,
   DiscardStatement,
+  ReturnStatement,
+  IfStatement,
+  ForStatement,
 } from './ast'
 import { type Token, tokenize } from './tokenizer'
 
@@ -48,9 +52,13 @@ export function parse(code: string): AST[] {
 
       if (token.type === 'keyword') {
         if (isQualifier(token.value) || isType(token.value) || token.value === 'const' || token.value === 'uniform') {
-          if (tokens[i + 2]?.value === '(') {
-            const body = getTokensUntil('}')
-            statement = { __brand: 'FunctionDeclaration', body }
+          if (tokens[i + 1]?.value === '(') {
+            const type = token.value
+            const name = tokens[i++].value
+            // TODO: parse
+            const args = getTokensUntil(')') as any
+            const body = getTokensUntil('}') as any
+            statement = new FunctionDeclaration(name, type, args, body)
           } else {
             const qualifiers: string[] = []
             while (tokens[i].type !== 'identifier') qualifiers.push(tokens[i++].value)
@@ -75,13 +83,48 @@ export function parse(code: string): AST[] {
           statement = new DiscardStatement()
         } else if (token.value === 'return') {
           const body = getTokensUntil(';')
-          statement = { __brand: 'ReturnStatement', body }
+          body.pop() // skip;
+
+          let argument = null
+          if (body.length) {
+            // TODO: parse expression
+          }
+
+          statement = new ReturnStatement(argument)
         } else if (token.value === 'if') {
-          const body = getTokensUntil('}')
-          statement = { __brand: 'IfStatement', body }
+          // TODO: parse expression
+          const test = getTokensUntil(')')
+          const consequent = getTokensUntil('}')
+          const alternate = null
+
+          statement = new IfStatement(test, consequent, alternate)
         } else if (token.value === 'for') {
+          const tests: (AST | null)[] = [null, null, null]
+          let j = 0
+
+          const loop = getTokensUntil(')')
+          loop.shift() // skip (
+          loop.pop() // skip )
+
+          let next = loop.shift()
+          while (next) {
+            if (next.value === ';') {
+              j++
+            } else {
+              // TODO: parse expressions
+              // @ts-ignore
+              tests[j] ??= []
+              // @ts-ignore
+              tests[j].push(next)
+            }
+
+            next = loop.shift()
+          }
+
+          const [init, test, update] = tests
           const body = getTokensUntil('}')
-          statement = { __brand: 'ForStatement', body }
+
+          statement = new ForStatement(init, test, update, body)
         }
       }
 
@@ -101,6 +144,14 @@ const glsl = /* glsl */ `
   flat in mat4 test;
 
   if (true) {
+    discard;
+  }
+
+  for (int i = 0; i < 10; i++) {
+    //
+  }
+
+  void main() {
     gl_FragColor = vec4(1, 0, 0, 1); // red
   }
 `

From a990ca4cf3e2e57a3664229c327aefe6f5f68552 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 02:56:14 -0600
Subject: [PATCH 11/64] chore: update demo

---
 demo/index.html | 3 +++
 src/parser.ts   | 1 +
 2 files changed, 4 insertions(+)

diff --git a/demo/index.html b/demo/index.html
index 5956760..d1b2715 100644
--- a/demo/index.html
+++ b/demo/index.html
@@ -5,6 +5,9 @@
     height: 100%;
   }
 </style>
+<script type="module">
+  import 'shaderkit'
+</script>
 <script type="module">
   {
     const canvas = document.body.appendChild(document.createElement('canvas'))
diff --git a/src/parser.ts b/src/parser.ts
index 8494519..9fa6a1c 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -156,4 +156,5 @@ const glsl = /* glsl */ `
   }
 `
 
+console.log(glsl)
 console.log(...parse(glsl))

From c41e02acb3ec8593695f6364c76fd0e3ec1e9147 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 04:43:30 -0600
Subject: [PATCH 12/64] chore: cleanup

---
 src/parser.ts | 231 +++++++++++++++++++++++++++-----------------------
 1 file changed, 127 insertions(+), 104 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 9fa6a1c..b11dcf9 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -12,128 +12,151 @@ import {
 } from './ast'
 import { type Token, tokenize } from './tokenizer'
 
+// TODO: this is GLSL-only, separate language constants
+const isType = RegExp.prototype.test.bind(/^(void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?)$/)
+const isQualifier = RegExp.prototype.test.bind(/^(in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp)$/)
+
 const isOpen = RegExp.prototype.test.bind(/^[\(\[\{]$/)
 const isClose = RegExp.prototype.test.bind(/^[\)\]\}]$/)
 
-/**
- * Parses a string of GLSL or WGSL code into an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
- */
-export function parse(code: string): AST[] {
-  // TODO: preserve
-  const tokens = tokenize(code).filter((token) => token.type !== 'whitespace' && token.type !== 'comment')
-  let i = 0
+let tokens: Token[] = []
+let i = 0
+
+function getTokensUntil(value: string): Token[] {
+  const output: Token[] = []
+  let scopeIndex = 0
+
+  while (i < tokens.length) {
+    const token = tokens[i++]
+    output.push(token)
+
+    if (isOpen(token.value)) scopeIndex++
+    if (isClose(token.value)) scopeIndex--
+
+    if (scopeIndex === 0 && token.value === value) break
+  }
+
+  return output
+}
+
+function parseFunction() {
+  const type = tokens[i].value
+  const name = tokens[i++].value
+  // TODO: parse
+  const args = getTokensUntil(')') as any
+  const body = getTokensUntil('}') as any
+  return new FunctionDeclaration(name, type, args, body)
+}
 
-  // TODO: this is GLSL-only, separate language constants
-  const isType = RegExp.prototype.test.bind(/^(void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?)$/)
-  const isQualifier = RegExp.prototype.test.bind(/^(in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp)$/)
+function parseVariable() {
+  const qualifiers: string[] = []
+  while (tokens[i].type !== 'identifier') qualifiers.push(tokens[i++].value)
+  const type = qualifiers.pop()!
 
-  function getTokensUntil(value: string): Token[] {
-    const output: Token[] = []
-    let scopeIndex = 0
+  const body = getTokensUntil(';')
+  const name = body.shift()!.value
+  body.pop() // skip ;
 
-    while (i < tokens.length) {
-      const token = tokens[i++]
-      output.push(token)
+  let value = null
+  if (body.length) {
+    // TODO: parse expression
+  }
+
+  return new VariableDeclaration(name, type, value, qualifiers)
+}
 
-      if (isOpen(token.value)) scopeIndex++
-      if (isClose(token.value)) scopeIndex--
+function parseReturn() {
+  const body = getTokensUntil(';')
+  body.pop() // skip ;
+
+  let argument = null
+  if (body.length) {
+    // TODO: parse expression
+  }
 
-      if (scopeIndex === 0 && token.value === value) break
+  return new ReturnStatement(argument)
+}
+
+function parseIf() {
+  // TODO: parse expression
+  const test = getTokensUntil(')')
+  const consequent = getTokensUntil('}')
+  const alternate = null
+
+  return new IfStatement(test, consequent, alternate)
+}
+
+function parseFor() {
+  const tests: (AST | null)[] = [null, null, null]
+  let j = 0
+
+  const loop = getTokensUntil(')')
+  loop.shift() // skip (
+  loop.pop() // skip )
+
+  let next = loop.shift()
+  while (next) {
+    if (next.value === ';') {
+      j++
+    } else {
+      // TODO: parse expressions
+      // @ts-ignore
+      tests[j] ??= []
+      // @ts-ignore
+      tests[j].push(next)
     }
 
-    return output
+    next = loop.shift()
   }
 
-  function parseBlock<T extends BlockStatement>(node: T): T {
-    while (i < tokens.length) {
-      const token = tokens[i++]
-
-      let statement: AST | null = null
-
-      if (token.type === 'keyword') {
-        if (isQualifier(token.value) || isType(token.value) || token.value === 'const' || token.value === 'uniform') {
-          if (tokens[i + 1]?.value === '(') {
-            const type = token.value
-            const name = tokens[i++].value
-            // TODO: parse
-            const args = getTokensUntil(')') as any
-            const body = getTokensUntil('}') as any
-            statement = new FunctionDeclaration(name, type, args, body)
-          } else {
-            const qualifiers: string[] = []
-            while (tokens[i].type !== 'identifier') qualifiers.push(tokens[i++].value)
-            const type = qualifiers.pop()!
-
-            const body = getTokensUntil(';')
-            const name = body.shift()!.value
-            body.pop() // skip ;
-
-            let value = null
-            if (body.length) {
-              // TODO: parse expression
-            }
-
-            statement = new VariableDeclaration(name, type, value, qualifiers)
-          }
-        } else if (token.value === 'continue') {
-          statement = new ContinueStatement()
-        } else if (token.value === 'break') {
-          statement = new BreakStatement()
-        } else if (token.value === 'discard') {
-          statement = new DiscardStatement()
-        } else if (token.value === 'return') {
-          const body = getTokensUntil(';')
-          body.pop() // skip;
-
-          let argument = null
-          if (body.length) {
-            // TODO: parse expression
-          }
-
-          statement = new ReturnStatement(argument)
-        } else if (token.value === 'if') {
-          // TODO: parse expression
-          const test = getTokensUntil(')')
-          const consequent = getTokensUntil('}')
-          const alternate = null
-
-          statement = new IfStatement(test, consequent, alternate)
-        } else if (token.value === 'for') {
-          const tests: (AST | null)[] = [null, null, null]
-          let j = 0
-
-          const loop = getTokensUntil(')')
-          loop.shift() // skip (
-          loop.pop() // skip )
-
-          let next = loop.shift()
-          while (next) {
-            if (next.value === ';') {
-              j++
-            } else {
-              // TODO: parse expressions
-              // @ts-ignore
-              tests[j] ??= []
-              // @ts-ignore
-              tests[j].push(next)
-            }
-
-            next = loop.shift()
-          }
-
-          const [init, test, update] = tests
-          const body = getTokensUntil('}')
-
-          statement = new ForStatement(init, test, update, body)
+  const [init, test, update] = tests
+  const body = getTokensUntil('}')
+
+  return new ForStatement(init, test, update, body)
+}
+
+function parseBlock<T extends BlockStatement>(node: T): T {
+  while (i < tokens.length) {
+    const token = tokens[i++]
+
+    let statement: AST | null = null
+
+    if (token.type === 'keyword') {
+      if (isQualifier(token.value) || isType(token.value) || token.value === 'const' || token.value === 'uniform') {
+        if (tokens[i + 1]?.value === '(') {
+          statement = parseFunction()
+        } else {
+          statement = parseVariable()
         }
+      } else if (token.value === 'continue') {
+        statement = new ContinueStatement()
+      } else if (token.value === 'break') {
+        statement = new BreakStatement()
+      } else if (token.value === 'discard') {
+        statement = new DiscardStatement()
+      } else if (token.value === 'return') {
+        statement = parseReturn()
+      } else if (token.value === 'if') {
+        statement = parseIf()
+      } else if (token.value === 'for') {
+        statement = parseFor()
       }
-
-      if (statement) node.body.push(statement)
     }
 
-    return node
+    if (statement) node.body.push(statement)
   }
 
+  return node
+}
+
+/**
+ * Parses a string of GLSL or WGSL code into an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
+ */
+export function parse(code: string): AST[] {
+  // TODO: preserve
+  tokens = tokenize(code).filter((token) => token.type !== 'whitespace' && token.type !== 'comment')
+  i = 0
+
   const program = new BlockStatement([])
   parseBlock(program)
 

From 080e520e1086a48f402ac44d111e598c0516d8d2 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 05:01:11 -0600
Subject: [PATCH 13/64] refactor: parse nested blocks

---
 src/parser.ts | 57 ++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 41 insertions(+), 16 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index b11dcf9..8f97ee8 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -19,8 +19,14 @@ const isQualifier = RegExp.prototype.test.bind(/^(in|out|inout|centroid|flat|smo
 const isOpen = RegExp.prototype.test.bind(/^[\(\[\{]$/)
 const isClose = RegExp.prototype.test.bind(/^[\)\]\}]$/)
 
+function getScopeIndex(token: Token): number {
+  if (isOpen(token.value)) return 1
+  if (isClose(token.value)) return -1
+  return 0
+}
+
 let tokens: Token[] = []
-let i = 0
+let i: number = 0
 
 function getTokensUntil(value: string): Token[] {
   const output: Token[] = []
@@ -30,16 +36,14 @@ function getTokensUntil(value: string): Token[] {
     const token = tokens[i++]
     output.push(token)
 
-    if (isOpen(token.value)) scopeIndex++
-    if (isClose(token.value)) scopeIndex--
-
+    scopeIndex += getScopeIndex(token)
     if (scopeIndex === 0 && token.value === value) break
   }
 
   return output
 }
 
-function parseFunction() {
+function parseFunction(): FunctionDeclaration {
   const type = tokens[i].value
   const name = tokens[i++].value
   // TODO: parse
@@ -48,7 +52,7 @@ function parseFunction() {
   return new FunctionDeclaration(name, type, args, body)
 }
 
-function parseVariable() {
+function parseVariable(): VariableDeclaration {
   const qualifiers: string[] = []
   while (tokens[i].type !== 'identifier') qualifiers.push(tokens[i++].value)
   const type = qualifiers.pop()!
@@ -65,7 +69,7 @@ function parseVariable() {
   return new VariableDeclaration(name, type, value, qualifiers)
 }
 
-function parseReturn() {
+function parseReturn(): ReturnStatement {
   const body = getTokensUntil(';')
   body.pop() // skip ;
 
@@ -77,16 +81,27 @@ function parseReturn() {
   return new ReturnStatement(argument)
 }
 
-function parseIf() {
+function parseIf(): IfStatement {
   // TODO: parse expression
   const test = getTokensUntil(')')
   const consequent = getTokensUntil('}')
-  const alternate = null
+
+  let alternate = null
+  if (tokens[i].value === 'else') {
+    i++
+
+    if (tokens[i].value === 'if') {
+      i++
+      alternate = parseIf()
+    } else {
+      alternate = parseBlock()
+    }
+  }
 
   return new IfStatement(test, consequent, alternate)
 }
 
-function parseFor() {
+function parseFor(): ForStatement {
   const tests: (AST | null)[] = [null, null, null]
   let j = 0
 
@@ -115,10 +130,18 @@ function parseFor() {
   return new ForStatement(init, test, update, body)
 }
 
-function parseBlock<T extends BlockStatement>(node: T): T {
+function parseBlock(): BlockStatement {
+  const body: AST[] = []
+
+  if (tokens[i].value === '{') i++
+  let scopeIndex = 0
+
   while (i < tokens.length) {
     const token = tokens[i++]
 
+    scopeIndex += getScopeIndex(token)
+    if (scopeIndex < 0) break
+
     let statement: AST | null = null
 
     if (token.type === 'keyword') {
@@ -143,10 +166,10 @@ function parseBlock<T extends BlockStatement>(node: T): T {
       }
     }
 
-    if (statement) node.body.push(statement)
+    if (statement) body.push(statement)
   }
 
-  return node
+  return new BlockStatement(body)
 }
 
 /**
@@ -157,9 +180,7 @@ export function parse(code: string): AST[] {
   tokens = tokenize(code).filter((token) => token.type !== 'whitespace' && token.type !== 'comment')
   i = 0
 
-  const program = new BlockStatement([])
-  parseBlock(program)
-
+  const program = parseBlock()
   return program.body
 }
 
@@ -168,6 +189,10 @@ const glsl = /* glsl */ `
 
   if (true) {
     discard;
+  } else if (false) {
+    //
+  } else {
+
   }
 
   for (int i = 0; i < 10; i++) {

From a15c438597ebd75e249f349978f1173e8f59d4fc Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 06:26:27 -0600
Subject: [PATCH 14/64] chore: abstract statement parse

---
 src/parser.ts | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 8f97ee8..79f7d6a 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -19,7 +19,7 @@ const isQualifier = RegExp.prototype.test.bind(/^(in|out|inout|centroid|flat|smo
 const isOpen = RegExp.prototype.test.bind(/^[\(\[\{]$/)
 const isClose = RegExp.prototype.test.bind(/^[\)\]\}]$/)
 
-function getScopeIndex(token: Token): number {
+function getScopeDelta(token: Token): number {
   if (isOpen(token.value)) return 1
   if (isClose(token.value)) return -1
   return 0
@@ -36,7 +36,7 @@ function getTokensUntil(value: string): Token[] {
     const token = tokens[i++]
     output.push(token)
 
-    scopeIndex += getScopeIndex(token)
+    scopeIndex += getScopeDelta(token)
     if (scopeIndex === 0 && token.value === value) break
   }
 
@@ -130,16 +130,14 @@ function parseFor(): ForStatement {
   return new ForStatement(init, test, update, body)
 }
 
-function parseBlock(): BlockStatement {
-  const body: AST[] = []
-
+function parseBody(body: AST[]): AST[] {
   if (tokens[i].value === '{') i++
   let scopeIndex = 0
 
   while (i < tokens.length) {
     const token = tokens[i++]
 
-    scopeIndex += getScopeIndex(token)
+    scopeIndex += getScopeDelta(token)
     if (scopeIndex < 0) break
 
     let statement: AST | null = null
@@ -169,6 +167,11 @@ function parseBlock(): BlockStatement {
     if (statement) body.push(statement)
   }
 
+  return body
+}
+
+function parseBlock(): BlockStatement {
+  const body = parseBody([])
   return new BlockStatement(body)
 }
 
@@ -180,8 +183,7 @@ export function parse(code: string): AST[] {
   tokens = tokenize(code).filter((token) => token.type !== 'whitespace' && token.type !== 'comment')
   i = 0
 
-  const program = parseBlock()
-  return program.body
+  return parseBody([])
 }
 
 const glsl = /* glsl */ `
@@ -192,7 +194,7 @@ const glsl = /* glsl */ `
   } else if (false) {
     //
   } else {
-
+    //
   }
 
   for (int i = 0; i < 10; i++) {

From 9b28dd18f288e01d6cb6cec68e8938fc057d7d82 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 07:03:43 -0600
Subject: [PATCH 15/64] refactor: parse while, do-while, switch-case

---
 src/parser.ts | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

diff --git a/src/parser.ts b/src/parser.ts
index 79f7d6a..eacdb2f 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -8,7 +8,11 @@ import {
   DiscardStatement,
   ReturnStatement,
   IfStatement,
+  WhileStatement,
   ForStatement,
+  DoWhileStatement,
+  SwitchStatement,
+  SwitchCase,
 } from './ast'
 import { type Token, tokenize } from './tokenizer'
 
@@ -101,6 +105,14 @@ function parseIf(): IfStatement {
   return new IfStatement(test, consequent, alternate)
 }
 
+function parseWhile(): WhileStatement {
+  // TODO: parse expression
+  const test = getTokensUntil(')')
+  const body = getTokensUntil('}')
+
+  return new WhileStatement(test, body)
+}
+
 function parseFor(): ForStatement {
   const tests: (AST | null)[] = [null, null, null]
   let j = 0
@@ -130,6 +142,53 @@ function parseFor(): ForStatement {
   return new ForStatement(init, test, update, body)
 }
 
+function parseDoWhile() {
+  // TODO: parse expression
+  const body = getTokensUntil('}')
+  i++ // skip while
+  const test = getTokensUntil(')')
+
+  return new DoWhileStatement(test, body)
+}
+
+function parseSwitch() {
+  const discriminant = getTokensUntil(')')
+  const body = getTokensUntil('}').slice(1, -1)
+
+  let j = -1
+  const cases: SwitchCase[] = []
+  while (body.length) {
+    const token = body.shift()!
+    if (token.value === 'case') {
+      const test = body.shift()!
+      body.shift() // skip :
+      cases.push(new SwitchCase(test, []))
+      j++
+    } else {
+      cases[j].consequent.push(token)
+    }
+  }
+
+  return new SwitchStatement(discriminant, cases)
+}
+
+function parseCase() {
+  const test = tokens[i++]
+  i++ // skip :
+
+  let consequent: AST[] = []
+  if (tokens[i].value === '{') {
+    parseBody(consequent)
+  } else {
+    // TODO: handle fall-through and unscoped
+    // while (i < tokens.length && tokens[i].value !== 'case') {
+    //   consequent.push(tokens[i++])
+    // }
+  }
+
+  return new SwitchCase(test, consequent)
+}
+
 function parseBody(body: AST[]): AST[] {
   if (tokens[i].value === '{') i++
   let scopeIndex = 0
@@ -159,8 +218,14 @@ function parseBody(body: AST[]): AST[] {
         statement = parseReturn()
       } else if (token.value === 'if') {
         statement = parseIf()
+      } else if (token.value === 'while') {
+        statement = parseWhile()
       } else if (token.value === 'for') {
         statement = parseFor()
+      } else if (token.value === 'do') {
+        statement = parseDoWhile()
+      } else if (token.value === 'switch') {
+        statement = parseSwitch()
       }
     }
 
@@ -201,6 +266,21 @@ const glsl = /* glsl */ `
     //
   }
 
+  while(true) {
+    //
+  }
+
+  do {
+    //
+  } while (true);
+
+  switch(true) {
+    case 0:
+      break;
+    case 1:
+      break;
+  }
+
   void main() {
     gl_FragColor = vec4(1, 0, 0, 1); // red
   }

From 7b87e70a50fc3aa051be5683f7931b4663cebbc9 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 07:04:14 -0600
Subject: [PATCH 16/64] chore: cleanup

---
 src/parser.ts | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index eacdb2f..ebb5d88 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -172,23 +172,6 @@ function parseSwitch() {
   return new SwitchStatement(discriminant, cases)
 }
 
-function parseCase() {
-  const test = tokens[i++]
-  i++ // skip :
-
-  let consequent: AST[] = []
-  if (tokens[i].value === '{') {
-    parseBody(consequent)
-  } else {
-    // TODO: handle fall-through and unscoped
-    // while (i < tokens.length && tokens[i].value !== 'case') {
-    //   consequent.push(tokens[i++])
-    // }
-  }
-
-  return new SwitchCase(test, consequent)
-}
-
 function parseBody(body: AST[]): AST[] {
   if (tokens[i].value === '{') i++
   let scopeIndex = 0

From cfe737965469e7314c68fc54a083bdb254669662 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 07:05:16 -0600
Subject: [PATCH 17/64] chore: cleanup

---
 src/parser.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index ebb5d88..bb6e04b 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -142,7 +142,7 @@ function parseFor(): ForStatement {
   return new ForStatement(init, test, update, body)
 }
 
-function parseDoWhile() {
+function parseDoWhile(): DoWhileStatement {
   // TODO: parse expression
   const body = getTokensUntil('}')
   i++ // skip while
@@ -151,7 +151,7 @@ function parseDoWhile() {
   return new DoWhileStatement(test, body)
 }
 
-function parseSwitch() {
+function parseSwitch(): SwitchStatement {
   const discriminant = getTokensUntil(')')
   const body = getTokensUntil('}').slice(1, -1)
 

From 03b4c3a38665cf2889e7de89f6d06be6da53b0ea Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 07:08:09 -0600
Subject: [PATCH 18/64] chore: parseBody => parseStatements

---
 src/parser.ts | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index bb6e04b..afd1827 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -172,7 +172,9 @@ function parseSwitch(): SwitchStatement {
   return new SwitchStatement(discriminant, cases)
 }
 
-function parseBody(body: AST[]): AST[] {
+function parseStatements(): AST[] {
+  const body: AST[] = []
+
   if (tokens[i].value === '{') i++
   let scopeIndex = 0
 
@@ -219,7 +221,7 @@ function parseBody(body: AST[]): AST[] {
 }
 
 function parseBlock(): BlockStatement {
-  const body = parseBody([])
+  const body = parseStatements()
   return new BlockStatement(body)
 }
 
@@ -231,7 +233,7 @@ export function parse(code: string): AST[] {
   tokens = tokenize(code).filter((token) => token.type !== 'whitespace' && token.type !== 'comment')
   i = 0
 
-  return parseBody([])
+  return parseStatements()
 }
 
 const glsl = /* glsl */ `

From b6f16ab0a01d5ee579125a5a3fde5e724f47a523 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 07:10:09 -0600
Subject: [PATCH 19/64] refactor: AST union extends Node

---
 src/ast.ts | 104 ++++++++++++++++++++++++++++++++---------------------
 1 file changed, 64 insertions(+), 40 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 26a8d56..9d46b5c 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -1,33 +1,33 @@
-export abstract class AST {}
+export abstract class Node {}
 
-export class Literal extends AST {
+export class Literal extends Node {
   constructor(public value: string | number | boolean) {
     super()
   }
 }
 
-export class Identifier extends AST {
+export class Identifier extends Node {
   constructor(public value: string) {
     super()
   }
 }
 
-export class VariableDeclaration extends AST {
-  constructor(public name: string, public type: AST, public value: AST | null, public qualifiers: AST[]) {
+export class VariableDeclaration extends Node {
+  constructor(public name: string, public type: Node, public value: Node | null, public qualifiers: Node[]) {
     super()
   }
 }
 
-export class BlockStatement extends AST {
-  constructor(public body: AST[]) {
+export class BlockStatement extends Node {
+  constructor(public body: Node[]) {
     super()
   }
 }
 
-export class FunctionDeclaration extends AST {
+export class FunctionDeclaration extends Node {
   constructor(
     public name: string,
-    public type: AST | null,
+    public type: Node | null,
     public args: VariableDeclaration[],
     public body: BlockStatement,
   ) {
@@ -35,92 +35,116 @@ export class FunctionDeclaration extends AST {
   }
 }
 
-export class CallExpression extends AST {
-  constructor(public callee: AST, public args: AST[]) {
+export class CallExpression extends Node {
+  constructor(public callee: Node, public args: Node[]) {
     super()
   }
 }
 
-export class MemberExpression extends AST {
-  constructor(public object: AST, public property: AST) {
+export class MemberExpression extends Node {
+  constructor(public object: Node, public property: Node) {
     super()
   }
 }
 
-export class ArrayExpression extends AST {
-  constructor(public members: AST[]) {
+export class ArrayExpression extends Node {
+  constructor(public members: Node[]) {
     super()
   }
 }
 
-export class IfStatement extends AST {
-  constructor(public test: AST, public consequent: AST, public alternate: AST | null) {
+export class IfStatement extends Node {
+  constructor(public test: Node, public consequent: Node, public alternate: Node | null) {
     super()
   }
 }
 
-export class WhileStatement extends AST {
-  constructor(public test: AST, public body: AST) {
+export class WhileStatement extends Node {
+  constructor(public test: Node, public body: Node) {
     super()
   }
 }
 
-export class ForStatement extends AST {
-  constructor(public init: AST | null, public test: AST | null, public update: AST | null, public body: AST) {
+export class ForStatement extends Node {
+  constructor(public init: Node | null, public test: Node | null, public update: Node | null, public body: Node) {
     super()
   }
 }
 
-export class DoWhileStatement extends AST {
-  constructor(public test: AST, public body: AST) {
+export class DoWhileStatement extends Node {
+  constructor(public test: Node, public body: Node) {
     super()
   }
 }
 
-export class SwitchCase extends AST {
-  constructor(public test: AST | null, public consequent: AST[]) {
+export class SwitchCase extends Node {
+  constructor(public test: Node | null, public consequent: Node[]) {
     super()
   }
 }
 
-export class SwitchStatement extends AST {
-  constructor(public discriminant: AST, public cases: SwitchCase[]) {
+export class SwitchStatement extends Node {
+  constructor(public discriminant: Node, public cases: SwitchCase[]) {
     super()
   }
 }
 
-export class StructDeclaration extends AST {
+export class StructDeclaration extends Node {
   constructor(public name: string, public members: VariableDeclaration[]) {
     super()
   }
 }
 
-export class UnaryExpression extends AST {
-  constructor(public operator: string, public argument: AST) {
+export class UnaryExpression extends Node {
+  constructor(public operator: string, public argument: Node) {
     super()
   }
 }
 
-export class BinaryExpression extends AST {
-  constructor(public operator: string, public left: AST, public right: AST) {
+export class BinaryExpression extends Node {
+  constructor(public operator: string, public left: Node, public right: Node) {
     super()
   }
 }
 
-export class TernaryExpression extends AST {
-  constructor(public test: AST, public consequent: AST, public alternate: AST) {
+export class TernaryExpression extends Node {
+  constructor(public test: Node, public consequent: Node, public alternate: Node) {
     super()
   }
 }
 
-export class ReturnStatement extends AST {
+export class ReturnStatement extends Node {
   constructor(public argument: Literal | Identifier | UnaryExpression | null) {
     super()
   }
 }
 
-export class ContinueStatement extends AST {}
-
-export class BreakStatement extends AST {}
-
-export class DiscardStatement extends AST {}
+export class ContinueStatement extends Node {}
+
+export class BreakStatement extends Node {}
+
+export class DiscardStatement extends Node {}
+
+export type AST =
+  | Literal
+  | Identifier
+  | VariableDeclaration
+  | BlockStatement
+  | FunctionDeclaration
+  | CallExpression
+  | MemberExpression
+  | ArrayExpression
+  | IfStatement
+  | WhileStatement
+  | ForStatement
+  | DoWhileStatement
+  | SwitchCase
+  | SwitchStatement
+  | StructDeclaration
+  | UnaryExpression
+  | BinaryExpression
+  | TernaryExpression
+  | ReturnStatement
+  | ContinueStatement
+  | BreakStatement
+  | DiscardStatement

From 8c60a908d0dee29af85d76c61c512888679c71b2 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Wed, 8 Nov 2023 23:12:54 -0600
Subject: [PATCH 20/64] refactor: harden qualifier gather

---
 src/parser.ts | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index afd1827..93e4d1c 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -58,7 +58,9 @@ function parseFunction(): FunctionDeclaration {
 
 function parseVariable(): VariableDeclaration {
   const qualifiers: string[] = []
-  while (tokens[i].type !== 'identifier') qualifiers.push(tokens[i++].value)
+  while (tokens[i] && tokens[i].type !== 'identifier') {
+    qualifiers.push(tokens[i++].value)
+  }
   const type = qualifiers.pop()!
 
   const body = getTokensUntil(';')
@@ -174,8 +176,6 @@ function parseSwitch(): SwitchStatement {
 
 function parseStatements(): AST[] {
   const body: AST[] = []
-
-  if (tokens[i].value === '{') i++
   let scopeIndex = 0
 
   while (i < tokens.length) {
@@ -221,6 +221,7 @@ function parseStatements(): AST[] {
 }
 
 function parseBlock(): BlockStatement {
+  if (tokens[i].value === '{') i++
   const body = parseStatements()
   return new BlockStatement(body)
 }

From 16d58496edd14307229430deb776559ff374cd3c Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 9 Nov 2023 05:32:21 -0600
Subject: [PATCH 21/64] refactor: cleanup var scan

---
 src/parser.ts | 43 ++++++++++++++++---------------------------
 1 file changed, 16 insertions(+), 27 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 93e4d1c..920a7e6 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -17,8 +17,11 @@ import {
 import { type Token, tokenize } from './tokenizer'
 
 // TODO: this is GLSL-only, separate language constants
-const isType = RegExp.prototype.test.bind(/^(void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?)$/)
-const isQualifier = RegExp.prototype.test.bind(/^(in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp)$/)
+const TYPE_REGEX = /void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?/
+const QUALIFIER_REGEX = /in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp/
+const VARIABLE_REGEX = new RegExp(`${TYPE_REGEX.source}|${QUALIFIER_REGEX.source}|const|uniform`)
+
+const isVariable = RegExp.prototype.test.bind(VARIABLE_REGEX)
 
 const isOpen = RegExp.prototype.test.bind(/^[\(\[\{]$/)
 const isClose = RegExp.prototype.test.bind(/^[\)\]\}]$/)
@@ -187,31 +190,17 @@ function parseStatements(): AST[] {
     let statement: AST | null = null
 
     if (token.type === 'keyword') {
-      if (isQualifier(token.value) || isType(token.value) || token.value === 'const' || token.value === 'uniform') {
-        if (tokens[i + 1]?.value === '(') {
-          statement = parseFunction()
-        } else {
-          statement = parseVariable()
-        }
-      } else if (token.value === 'continue') {
-        statement = new ContinueStatement()
-      } else if (token.value === 'break') {
-        statement = new BreakStatement()
-      } else if (token.value === 'discard') {
-        statement = new DiscardStatement()
-      } else if (token.value === 'return') {
-        statement = parseReturn()
-      } else if (token.value === 'if') {
-        statement = parseIf()
-      } else if (token.value === 'while') {
-        statement = parseWhile()
-      } else if (token.value === 'for') {
-        statement = parseFor()
-      } else if (token.value === 'do') {
-        statement = parseDoWhile()
-      } else if (token.value === 'switch') {
-        statement = parseSwitch()
-      }
+      if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
+      else if (isVariable(token.value)) statement = parseVariable()
+      else if (token.value === 'continue') statement = new ContinueStatement()
+      else if (token.value === 'break') statement = new BreakStatement()
+      else if (token.value === 'discard') statement = new DiscardStatement()
+      else if (token.value === 'return') statement = parseReturn()
+      else if (token.value === 'if') statement = parseIf()
+      else if (token.value === 'while') statement = parseWhile()
+      else if (token.value === 'for') statement = parseFor()
+      else if (token.value === 'do') statement = parseDoWhile()
+      else if (token.value === 'switch') statement = parseSwitch()
     }
 
     if (statement) body.push(statement)

From 4f34a8deb986edd8a34777de6c206e6558d0c369 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 9 Nov 2023 05:50:44 -0600
Subject: [PATCH 22/64] refactor: handle default switch case

---
 src/parser.ts | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 920a7e6..bebaa24 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -164,9 +164,9 @@ function parseSwitch(): SwitchStatement {
   const cases: SwitchCase[] = []
   while (body.length) {
     const token = body.shift()!
-    if (token.value === 'case') {
-      const test = body.shift()!
-      body.shift() // skip :
+    if (token.value === 'case' || token.value === 'default') {
+      const test = body.shift() ?? null
+      if (test) body.shift() // skip :
       cases.push(new SwitchCase(test, []))
       j++
     } else {
@@ -254,6 +254,8 @@ const glsl = /* glsl */ `
       break;
     case 1:
       break;
+    default:
+      //
   }
 
   void main() {

From 7745c2218327b6e49f56415f0d3ef2c2ae13c9c2 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 9 Nov 2023 06:20:53 -0600
Subject: [PATCH 23/64] refactor: parse block scopes

---
 src/parser.ts | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index bebaa24..c21f3ff 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -55,7 +55,7 @@ function parseFunction(): FunctionDeclaration {
   const name = tokens[i++].value
   // TODO: parse
   const args = getTokensUntil(')') as any
-  const body = getTokensUntil('}') as any
+  const body = parseBlock()
   return new FunctionDeclaration(name, type, args, body)
 }
 
@@ -66,7 +66,7 @@ function parseVariable(): VariableDeclaration {
   }
   const type = qualifiers.pop()!
 
-  const body = getTokensUntil(';')
+  const body = getTokensUntil(';') // TODO, comma-separated lists
   const name = body.shift()!.value
   body.pop() // skip ;
 
@@ -93,7 +93,7 @@ function parseReturn(): ReturnStatement {
 function parseIf(): IfStatement {
   // TODO: parse expression
   const test = getTokensUntil(')')
-  const consequent = getTokensUntil('}')
+  const consequent = parseBlock()
 
   let alternate = null
   if (tokens[i].value === 'else') {
@@ -113,7 +113,7 @@ function parseIf(): IfStatement {
 function parseWhile(): WhileStatement {
   // TODO: parse expression
   const test = getTokensUntil(')')
-  const body = getTokensUntil('}')
+  const body = parseBlock()
 
   return new WhileStatement(test, body)
 }
@@ -142,14 +142,14 @@ function parseFor(): ForStatement {
   }
 
   const [init, test, update] = tests
-  const body = getTokensUntil('}')
+  const body = parseBlock()
 
   return new ForStatement(init, test, update, body)
 }
 
 function parseDoWhile(): DoWhileStatement {
   // TODO: parse expression
-  const body = getTokensUntil('}')
+  const body = parseBlock()
   i++ // skip while
   const test = getTokensUntil(')')
 
@@ -259,7 +259,7 @@ const glsl = /* glsl */ `
   }
 
   void main() {
-    gl_FragColor = vec4(1, 0, 0, 1); // red
+    discard;
   }
 `
 

From 1118ca2ea6735fee94d61a07b7f02707bdb89efa Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 9 Nov 2023 06:27:06 -0600
Subject: [PATCH 24/64] refactor: cleanup for parse

---
 src/parser.ts | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index c21f3ff..123d7c6 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -53,7 +53,7 @@ function getTokensUntil(value: string): Token[] {
 function parseFunction(): FunctionDeclaration {
   const type = tokens[i].value
   const name = tokens[i++].value
-  // TODO: parse
+  // TODO: parse expressions
   const args = getTokensUntil(')') as any
   const body = parseBlock()
   return new FunctionDeclaration(name, type, args, body)
@@ -122,12 +122,9 @@ function parseFor(): ForStatement {
   const tests: (AST | null)[] = [null, null, null]
   let j = 0
 
-  const loop = getTokensUntil(')')
-  loop.shift() // skip (
-  loop.pop() // skip )
-
-  let next = loop.shift()
-  while (next) {
+  const loop = getTokensUntil(')').slice(1, -1)
+  while (loop.length) {
+    const next = loop.shift()!
     if (next.value === ';') {
       j++
     } else {
@@ -137,8 +134,6 @@ function parseFor(): ForStatement {
       // @ts-ignore
       tests[j].push(next)
     }
-
-    next = loop.shift()
   }
 
   const [init, test, update] = tests

From 3707f3870a7217a84e1af31a7175d4928fda1986 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 9 Nov 2023 06:31:43 -0600
Subject: [PATCH 25/64] refactor: cleanup for parse

---
 src/parser.ts | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 123d7c6..7af4f81 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -119,7 +119,7 @@ function parseWhile(): WhileStatement {
 }
 
 function parseFor(): ForStatement {
-  const tests: (AST | null)[] = [null, null, null]
+  const tests: [init?: AST, test?: AST, update?: AST] = []
   let j = 0
 
   const loop = getTokensUntil(')').slice(1, -1)
@@ -129,14 +129,12 @@ function parseFor(): ForStatement {
       j++
     } else {
       // TODO: parse expressions
-      // @ts-ignore
-      tests[j] ??= []
-      // @ts-ignore
-      tests[j].push(next)
+      const test = (tests[j] ??= []) as Token[]
+      test.push(next)
     }
   }
 
-  const [init, test, update] = tests
+  const [init = null, test = null, update = null] = tests
   const body = parseBlock()
 
   return new ForStatement(init, test, update, body)

From 9d8dc7d8777acbb73dedac23811b3dd577a8e05e Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 9 Nov 2023 07:24:28 -0600
Subject: [PATCH 26/64] refactor: skip assignment expressions

---
 src/parser.ts | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 7af4f81..2bf8627 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -184,8 +184,7 @@ function parseStatements(): AST[] {
 
     if (token.type === 'keyword') {
       if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
-      else if (isVariable(token.value)) statement = parseVariable()
-      else if (token.value === 'continue') statement = new ContinueStatement()
+      else if (token.value === 'continue' && tokens[i]?.value !== '(') statement = new ContinueStatement()
       else if (token.value === 'break') statement = new BreakStatement()
       else if (token.value === 'discard') statement = new DiscardStatement()
       else if (token.value === 'return') statement = parseReturn()
@@ -252,7 +251,7 @@ const glsl = /* glsl */ `
   }
 
   void main() {
-    discard;
+    gl_FragColor = vec4(1, 0, 0, 1); // red
   }
 `
 

From 9652414bc1ae5daf7bb5dfb088392824065a0b0e Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 9 Nov 2023 07:25:22 -0600
Subject: [PATCH 27/64] fix: unmangle

---
 src/parser.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/parser.ts b/src/parser.ts
index 2bf8627..cf55622 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -184,7 +184,8 @@ function parseStatements(): AST[] {
 
     if (token.type === 'keyword') {
       if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
-      else if (token.value === 'continue' && tokens[i]?.value !== '(') statement = new ContinueStatement()
+      else if (isVariable(token.value) && tokens[i]?.value !== '(') statement = parseVariable()
+      if (token.value === 'continue') statement = new ContinueStatement()
       else if (token.value === 'break') statement = new BreakStatement()
       else if (token.value === 'discard') statement = new DiscardStatement()
       else if (token.value === 'return') statement = parseReturn()

From 1dffe01fb8837815f10d43404de88f0168067060 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 9 Nov 2023 15:55:06 -0600
Subject: [PATCH 28/64] refactor: back-track for declarations

---
 src/parser.ts | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index cf55622..8c18bdc 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -51,22 +51,23 @@ function getTokensUntil(value: string): Token[] {
 }
 
 function parseFunction(): FunctionDeclaration {
-  const type = tokens[i].value
+  const type = tokens[i - 1].value
   const name = tokens[i++].value
   // TODO: parse expressions
-  const args = getTokensUntil(')') as any
+  const args = getTokensUntil(')').slice(1, -1) as unknown as VariableDeclaration[]
   const body = parseBlock()
   return new FunctionDeclaration(name, type, args, body)
 }
 
 function parseVariable(): VariableDeclaration {
+  i--
   const qualifiers: string[] = []
   while (tokens[i] && tokens[i].type !== 'identifier') {
     qualifiers.push(tokens[i++].value)
   }
   const type = qualifiers.pop()!
 
-  const body = getTokensUntil(';') // TODO, comma-separated lists
+  const body = getTokensUntil(';') // TODO: comma-separated lists
   const name = body.shift()!.value
   body.pop() // skip ;
 
@@ -92,7 +93,7 @@ function parseReturn(): ReturnStatement {
 
 function parseIf(): IfStatement {
   // TODO: parse expression
-  const test = getTokensUntil(')')
+  const test = getTokensUntil(')').slice(1, -1)
   const consequent = parseBlock()
 
   let alternate = null
@@ -112,7 +113,7 @@ function parseIf(): IfStatement {
 
 function parseWhile(): WhileStatement {
   // TODO: parse expression
-  const test = getTokensUntil(')')
+  const test = getTokensUntil(')').slice(1, -1)
   const body = parseBlock()
 
   return new WhileStatement(test, body)
@@ -141,9 +142,9 @@ function parseFor(): ForStatement {
 }
 
 function parseDoWhile(): DoWhileStatement {
-  // TODO: parse expression
   const body = parseBlock()
   i++ // skip while
+  // TODO: parse expression
   const test = getTokensUntil(')')
 
   return new DoWhileStatement(test, body)
@@ -158,11 +159,12 @@ function parseSwitch(): SwitchStatement {
   while (body.length) {
     const token = body.shift()!
     if (token.value === 'case' || token.value === 'default') {
-      const test = body.shift() ?? null
+      const test = body.shift() ?? null // TODO: parse literal/identifier
       if (test) body.shift() // skip :
       cases.push(new SwitchCase(test, []))
       j++
     } else {
+      // TODO: parse expression
       cases[j].consequent.push(token)
     }
   }
@@ -203,7 +205,7 @@ function parseStatements(): AST[] {
 }
 
 function parseBlock(): BlockStatement {
-  if (tokens[i].value === '{') i++
+  i++ // skip {
   const body = parseStatements()
   return new BlockStatement(body)
 }

From 8acba65ea720f8c9f336b6b8246aa082a31017b0 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 9 Nov 2023 21:32:24 -0600
Subject: [PATCH 29/64] chore: cleanup

---
 demo/index.html | 4 ++--
 src/parser.ts   | 9 +++++----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/demo/index.html b/demo/index.html
index 3d4f370..ca3d0d8 100644
--- a/demo/index.html
+++ b/demo/index.html
@@ -9,7 +9,7 @@
   import 'shaderkit'
 </script>
 <script type="module">
-  {
+  if (false) {
     const canvas = document.body.appendChild(document.createElement('canvas'))
     const gl = canvas.getContext('webgl2')
     const vertex = gl.createShader(gl.VERTEX_SHADER)
@@ -52,7 +52,7 @@
   }
 </script>
 <script type="module">
-  {
+  if (false) {
     const canvas = document.body.appendChild(document.createElement('canvas'))
     const context = canvas.getContext('webgpu')
     const format = navigator.gpu.getPreferredCanvasFormat()
diff --git a/src/parser.ts b/src/parser.ts
index 8c18bdc..0eb4488 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -129,7 +129,7 @@ function parseFor(): ForStatement {
     if (next.value === ';') {
       j++
     } else {
-      // TODO: parse expressions
+      // TODO: parse expression
       const test = (tests[j] ??= []) as Token[]
       test.push(next)
     }
@@ -145,13 +145,14 @@ function parseDoWhile(): DoWhileStatement {
   const body = parseBlock()
   i++ // skip while
   // TODO: parse expression
-  const test = getTokensUntil(')')
+  const test = getTokensUntil(')').slice(1, -1)
 
   return new DoWhileStatement(test, body)
 }
 
 function parseSwitch(): SwitchStatement {
-  const discriminant = getTokensUntil(')')
+  // TODO: parse expression
+  const discriminant = getTokensUntil(')').slice(1, -1)
   const body = getTokensUntil('}').slice(1, -1)
 
   let j = -1
@@ -187,7 +188,7 @@ function parseStatements(): AST[] {
     if (token.type === 'keyword') {
       if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
       else if (isVariable(token.value) && tokens[i]?.value !== '(') statement = parseVariable()
-      if (token.value === 'continue') statement = new ContinueStatement()
+      else if (token.value === 'continue') statement = new ContinueStatement()
       else if (token.value === 'break') statement = new BreakStatement()
       else if (token.value === 'discard') statement = new DiscardStatement()
       else if (token.value === 'return') statement = parseReturn()

From 538051103f5d1629f34f3dc8619897f818ffb899 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Fri, 10 Nov 2023 00:18:10 -0600
Subject: [PATCH 30/64] refactor: parse struct

---
 src/parser.ts | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/parser.ts b/src/parser.ts
index 0eb4488..70f1c99 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -13,6 +13,7 @@ import {
   DoWhileStatement,
   SwitchStatement,
   SwitchCase,
+  StructDeclaration,
 } from './ast'
 import { type Token, tokenize } from './tokenizer'
 
@@ -79,6 +80,15 @@ function parseVariable(): VariableDeclaration {
   return new VariableDeclaration(name, type, value, qualifiers)
 }
 
+function parseStruct(): StructDeclaration {
+  const name = tokens[i++].value
+  // TODO: parse expressions
+  const members = getTokensUntil('}').slice(1, -1) as unknown as VariableDeclaration[]
+  i++ // skip ;
+
+  return new StructDeclaration(name, members)
+}
+
 function parseReturn(): ReturnStatement {
   const body = getTokensUntil(';')
   body.pop() // skip ;
@@ -188,6 +198,7 @@ function parseStatements(): AST[] {
     if (token.type === 'keyword') {
       if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
       else if (isVariable(token.value) && tokens[i]?.value !== '(') statement = parseVariable()
+      else if (token.value === 'struct') statement = parseStruct()
       else if (token.value === 'continue') statement = new ContinueStatement()
       else if (token.value === 'break') statement = new BreakStatement()
       else if (token.value === 'discard') statement = new DiscardStatement()
@@ -225,6 +236,10 @@ export function parse(code: string): AST[] {
 const glsl = /* glsl */ `
   flat in mat4 test;
 
+  struct foo {
+    bool isStruct;
+  };
+
   if (true) {
     discard;
   } else if (false) {

From 1f8a5154a7fa03c317f615ba6e12735525ad7b78 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Fri, 10 Nov 2023 00:22:27 -0600
Subject: [PATCH 31/64] refactor: functions have optional body

---
 src/ast.ts    | 2 +-
 src/parser.ts | 8 +++++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 9d46b5c..44b80e5 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -29,7 +29,7 @@ export class FunctionDeclaration extends Node {
     public name: string,
     public type: Node | null,
     public args: VariableDeclaration[],
-    public body: BlockStatement,
+    public body: BlockStatement | null,
   ) {
     super()
   }
diff --git a/src/parser.ts b/src/parser.ts
index 70f1c99..002d3b1 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -56,7 +56,11 @@ function parseFunction(): FunctionDeclaration {
   const name = tokens[i++].value
   // TODO: parse expressions
   const args = getTokensUntil(')').slice(1, -1) as unknown as VariableDeclaration[]
-  const body = parseBlock()
+
+  let body = null
+  if (tokens[i].value === ';') i++ // skip ;
+  else body = parseBlock()
+
   return new FunctionDeclaration(name, type, args, body)
 }
 
@@ -269,6 +273,8 @@ const glsl = /* glsl */ `
       //
   }
 
+  void method();
+
   void main() {
     gl_FragColor = vec4(1, 0, 0, 1); // red
   }

From dd06092fff1eecad7fb7d4dd9eed36ddae62a95d Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Fri, 10 Nov 2023 03:01:29 -0600
Subject: [PATCH 32/64] refactor: parse struct members

---
 src/parser.ts | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 002d3b1..7e09341 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -86,8 +86,13 @@ function parseVariable(): VariableDeclaration {
 
 function parseStruct(): StructDeclaration {
   const name = tokens[i++].value
-  // TODO: parse expressions
-  const members = getTokensUntil('}').slice(1, -1) as unknown as VariableDeclaration[]
+  i++ // skip {
+  const members: VariableDeclaration[] = []
+  while (tokens[i] && tokens[i].value !== '}') {
+    i++ // TODO: remove backtrack hack
+    members.push(parseVariable())
+  }
+  i++ // skip }
   i++ // skip ;
 
   return new StructDeclaration(name, members)
@@ -242,6 +247,7 @@ const glsl = /* glsl */ `
 
   struct foo {
     bool isStruct;
+    vec4 color;
   };
 
   if (true) {

From 95f40e4136d7ae946c7b38220dd9bf0dd6d39ebf Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Fri, 10 Nov 2023 14:42:28 -0600
Subject: [PATCH 33/64] refactor: split gather into read/consume

---
 src/parser.ts | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 7e09341..7beb76e 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -36,12 +36,12 @@ function getScopeDelta(token: Token): number {
 let tokens: Token[] = []
 let i: number = 0
 
-function getTokensUntil(value: string): Token[] {
+function readUntil(value: string, body: Token[], offset: number = 0): Token[] {
   const output: Token[] = []
   let scopeIndex = 0
 
-  while (i < tokens.length) {
-    const token = tokens[i++]
+  while (offset < body.length) {
+    const token = body[offset++]
     output.push(token)
 
     scopeIndex += getScopeDelta(token)
@@ -51,11 +51,17 @@ function getTokensUntil(value: string): Token[] {
   return output
 }
 
+function consumeUntil(value: string): Token[] {
+  const output = readUntil(value, tokens, i)
+  i += output.length
+  return output
+}
+
 function parseFunction(): FunctionDeclaration {
   const type = tokens[i - 1].value
   const name = tokens[i++].value
   // TODO: parse expressions
-  const args = getTokensUntil(')').slice(1, -1) as unknown as VariableDeclaration[]
+  const args = consumeUntil(')').slice(1, -1) as unknown as VariableDeclaration[]
 
   let body = null
   if (tokens[i].value === ';') i++ // skip ;
@@ -72,7 +78,7 @@ function parseVariable(): VariableDeclaration {
   }
   const type = qualifiers.pop()!
 
-  const body = getTokensUntil(';') // TODO: comma-separated lists
+  const body = consumeUntil(';') // TODO: comma-separated lists
   const name = body.shift()!.value
   body.pop() // skip ;
 
@@ -99,7 +105,7 @@ function parseStruct(): StructDeclaration {
 }
 
 function parseReturn(): ReturnStatement {
-  const body = getTokensUntil(';')
+  const body = consumeUntil(';')
   body.pop() // skip ;
 
   let argument = null
@@ -112,7 +118,7 @@ function parseReturn(): ReturnStatement {
 
 function parseIf(): IfStatement {
   // TODO: parse expression
-  const test = getTokensUntil(')').slice(1, -1)
+  const test = consumeUntil(')').slice(1, -1)
   const consequent = parseBlock()
 
   let alternate = null
@@ -132,7 +138,7 @@ function parseIf(): IfStatement {
 
 function parseWhile(): WhileStatement {
   // TODO: parse expression
-  const test = getTokensUntil(')').slice(1, -1)
+  const test = consumeUntil(')').slice(1, -1)
   const body = parseBlock()
 
   return new WhileStatement(test, body)
@@ -142,7 +148,7 @@ function parseFor(): ForStatement {
   const tests: [init?: AST, test?: AST, update?: AST] = []
   let j = 0
 
-  const loop = getTokensUntil(')').slice(1, -1)
+  const loop = consumeUntil(')').slice(1, -1)
   while (loop.length) {
     const next = loop.shift()!
     if (next.value === ';') {
@@ -164,15 +170,15 @@ function parseDoWhile(): DoWhileStatement {
   const body = parseBlock()
   i++ // skip while
   // TODO: parse expression
-  const test = getTokensUntil(')').slice(1, -1)
+  const test = consumeUntil(')').slice(1, -1)
 
   return new DoWhileStatement(test, body)
 }
 
 function parseSwitch(): SwitchStatement {
   // TODO: parse expression
-  const discriminant = getTokensUntil(')').slice(1, -1)
-  const body = getTokensUntil('}').slice(1, -1)
+  const discriminant = consumeUntil(')').slice(1, -1)
+  const body = consumeUntil('}').slice(1, -1)
 
   let j = -1
   const cases: SwitchCase[] = []

From 7773c80237f6ee4afd210116f00fb97d89928bc0 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 11 Nov 2023 08:08:20 -0600
Subject: [PATCH 34/64] refactor: parse expressions

---
 src/ast.ts    |   2 +-
 src/parser.ts | 189 +++++++++++++++++++++++++++++++++++++++++---------
 2 files changed, 156 insertions(+), 35 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 44b80e5..c18e148 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -1,7 +1,7 @@
 export abstract class Node {}
 
 export class Literal extends Node {
-  constructor(public value: string | number | boolean) {
+  constructor(public value: string /*| number | boolean*/) {
     super()
   }
 }
diff --git a/src/parser.ts b/src/parser.ts
index 7beb76e..ace05c0 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,5 +1,12 @@
 import {
   type AST,
+  Identifier,
+  Literal,
+  CallExpression,
+  UnaryExpression,
+  MemberExpression,
+  TernaryExpression,
+  BinaryExpression,
   BlockStatement,
   FunctionDeclaration,
   VariableDeclaration,
@@ -17,6 +24,43 @@ import {
 } from './ast'
 import { type Token, tokenize } from './tokenizer'
 
+const UNARY_OPERATORS = ['+', '-', '~', '!', '++', '--']
+
+const BINARY_OPERATORS = [
+  ',',
+  '>>=',
+  '<<=',
+  '|=',
+  '&=',
+  '^=',
+  '%=',
+  '/=',
+  '*=',
+  '-=',
+  '+=',
+  '=',
+  '?',
+  '||',
+  '^^',
+  '&&',
+  '|',
+  '^',
+  '&',
+  '!=',
+  '==',
+  '>=',
+  '<=',
+  '>',
+  '<',
+  '>>',
+  '<<',
+  '+',
+  '-',
+  '%',
+  '/',
+  '*',
+]
+
 // TODO: this is GLSL-only, separate language constants
 const TYPE_REGEX = /void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?/
 const QUALIFIER_REGEX = /in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp/
@@ -57,10 +101,91 @@ function consumeUntil(value: string): Token[] {
   return output
 }
 
+function parseExpression(body: Token[]): AST | null {
+  if (body.length === 0) return null
+
+  let scopeIndex = 0
+
+  for (const operator of BINARY_OPERATORS) {
+    for (let i = 1; i < body.length - 1; i++) {
+      const token = body[i]
+      if (token.type !== 'symbol') continue
+
+      scopeIndex += getScopeDelta(token)
+
+      if (scopeIndex === 0 && token.value === operator) {
+        if (operator === '?') {
+          const testBody = body.slice(0, i)
+          const consequentBody = readUntil(':', body, i + 1).slice(0, -1)
+          const alternateBody = body.slice(i + consequentBody.length + 2)
+
+          const test = parseExpression(testBody)!
+          const consequent = parseExpression(consequentBody)!
+          const alternate = parseExpression(alternateBody)!
+
+          return new TernaryExpression(test, consequent, alternate)
+        } else {
+          const left = parseExpression(body.slice(0, i))!
+          const right = parseExpression(body.slice(i + 1, body.length))!
+
+          return new BinaryExpression(operator, left, right)
+        }
+      }
+
+      if (scopeIndex < 0) {
+        return parseExpression(body.slice(0, i))
+      }
+    }
+  }
+
+  const first = body[0]
+  const last = body[body.length - 1]
+  if (UNARY_OPERATORS.includes(first.value)) {
+    const right = parseExpression(body.slice(1))!
+    return new UnaryExpression(first.value, right)
+  } else if (UNARY_OPERATORS.includes(last.value)) {
+    const argument = parseExpression(body.slice(0, body.length - 1))!
+    return new UnaryExpression(last.value, argument)
+  }
+
+  if (first.value === '(') {
+    const leftBody = readUntil(')', body)
+    const left = parseExpression(leftBody.slice(1, leftBody.length - 1))!
+
+    const operator = body[leftBody.length]
+    if (operator) {
+      const rightBody = body.slice(leftBody.length + 1)
+      const right = parseExpression(rightBody)!
+
+      return new BinaryExpression(operator.value, left, right)
+    }
+
+    return left
+  }
+
+  if (first.type === 'bool' || first.type === 'int' || first.type === 'float') {
+    return new Literal(first.value)
+  } else if (first.type === 'identifier' || first.type === 'keyword') {
+    const second = body[1]
+
+    if (!second) {
+      return new Identifier(first.value)
+    } else if (second.value === '(') {
+      const args: AST[] = [] // TODO: parse args
+      return new CallExpression(first.value, args)
+    } else if (second.value === '.' || second.value === '[') {
+      const third = body[2]
+      return new MemberExpression(first.value, third.value)
+    }
+  }
+
+  return null
+}
+
 function parseFunction(): FunctionDeclaration {
-  const type = tokens[i - 1].value
+  const type = tokens[i - 1].value // TODO: remove backtrack hack
   const name = tokens[i++].value
-  // TODO: parse expressions
+  // TODO: parse args
   const args = consumeUntil(')').slice(1, -1) as unknown as VariableDeclaration[]
 
   let body = null
@@ -71,7 +196,7 @@ function parseFunction(): FunctionDeclaration {
 }
 
 function parseVariable(): VariableDeclaration {
-  i--
+  i-- // TODO: remove backtrack hack
   const qualifiers: string[] = []
   while (tokens[i] && tokens[i].type !== 'identifier') {
     qualifiers.push(tokens[i++].value)
@@ -82,10 +207,7 @@ function parseVariable(): VariableDeclaration {
   const name = body.shift()!.value
   body.pop() // skip ;
 
-  let value = null
-  if (body.length) {
-    // TODO: parse expression
-  }
+  const value = parseExpression(body)
 
   return new VariableDeclaration(name, type, value, qualifiers)
 }
@@ -108,22 +230,18 @@ function parseReturn(): ReturnStatement {
   const body = consumeUntil(';')
   body.pop() // skip ;
 
-  let argument = null
-  if (body.length) {
-    // TODO: parse expression
-  }
+  const argument = parseExpression(body)
 
-  return new ReturnStatement(argument)
+  return new ReturnStatement(argument as any)
 }
 
 function parseIf(): IfStatement {
-  // TODO: parse expression
-  const test = consumeUntil(')').slice(1, -1)
+  const test = parseExpression(consumeUntil(')'))!
   const consequent = parseBlock()
 
   let alternate = null
   if (tokens[i].value === 'else') {
-    i++
+    i++ // TODO: remove backtrack hack
 
     if (tokens[i].value === 'if') {
       i++
@@ -137,15 +255,14 @@ function parseIf(): IfStatement {
 }
 
 function parseWhile(): WhileStatement {
-  // TODO: parse expression
-  const test = consumeUntil(')').slice(1, -1)
+  const test = parseExpression(consumeUntil(')'))!
   const body = parseBlock()
 
   return new WhileStatement(test, body)
 }
 
 function parseFor(): ForStatement {
-  const tests: [init?: AST, test?: AST, update?: AST] = []
+  const tests: [init: Token[], test: Token[], update: Token[]] = [[], [], []]
   let j = 0
 
   const loop = consumeUntil(')').slice(1, -1)
@@ -154,13 +271,14 @@ function parseFor(): ForStatement {
     if (next.value === ';') {
       j++
     } else {
-      // TODO: parse expression
-      const test = (tests[j] ??= []) as Token[]
-      test.push(next)
+      tests[j].push(next)
     }
   }
 
-  const [init = null, test = null, update = null] = tests
+  const init = parseExpression(tests[0])
+  const test = parseExpression(tests[1])
+  const update = parseExpression(tests[2])
+
   const body = parseBlock()
 
   return new ForStatement(init, test, update, body)
@@ -169,15 +287,14 @@ function parseFor(): ForStatement {
 function parseDoWhile(): DoWhileStatement {
   const body = parseBlock()
   i++ // skip while
-  // TODO: parse expression
-  const test = consumeUntil(')').slice(1, -1)
+  const test = parseExpression(consumeUntil(')'))!
+  i++ // skip ;
 
   return new DoWhileStatement(test, body)
 }
 
 function parseSwitch(): SwitchStatement {
-  // TODO: parse expression
-  const discriminant = consumeUntil(')').slice(1, -1)
+  const discriminant = parseExpression(consumeUntil(')'))
   const body = consumeUntil('}').slice(1, -1)
 
   let j = -1
@@ -185,17 +302,16 @@ function parseSwitch(): SwitchStatement {
   while (body.length) {
     const token = body.shift()!
     if (token.value === 'case' || token.value === 'default') {
-      const test = body.shift() ?? null // TODO: parse literal/identifier
-      if (test) body.shift() // skip :
+      const test = token.value === 'case' ? parseExpression([body.shift()!]) : null
       cases.push(new SwitchCase(test, []))
       j++
     } else {
-      // TODO: parse expression
+      // TODO: parse scope
       cases[j].consequent.push(token)
     }
   }
 
-  return new SwitchStatement(discriminant, cases)
+  return new SwitchStatement(discriminant!, cases)
 }
 
 function parseStatements(): AST[] {
@@ -214,9 +330,9 @@ function parseStatements(): AST[] {
       if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
       else if (isVariable(token.value) && tokens[i]?.value !== '(') statement = parseVariable()
       else if (token.value === 'struct') statement = parseStruct()
-      else if (token.value === 'continue') statement = new ContinueStatement()
-      else if (token.value === 'break') statement = new BreakStatement()
-      else if (token.value === 'discard') statement = new DiscardStatement()
+      else if (token.value === 'continue') (statement = new ContinueStatement()), i++
+      else if (token.value === 'break') (statement = new BreakStatement()), i++
+      else if (token.value === 'discard') (statement = new DiscardStatement()), i++
       else if (token.value === 'return') statement = parseReturn()
       else if (token.value === 'if') statement = parseIf()
       else if (token.value === 'while') statement = parseWhile()
@@ -225,7 +341,12 @@ function parseStatements(): AST[] {
       else if (token.value === 'switch') statement = parseSwitch()
     }
 
-    if (statement) body.push(statement)
+    if (statement) {
+      body.push(statement)
+    } else {
+      const expression = parseExpression([token, ...consumeUntil(';').slice(0, -1)])
+      if (expression) body.push(expression)
+    }
   }
 
   return body

From e369a4b590405bf0e0b81b39dcc8a45c87b54f2a Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 11 Nov 2023 15:57:07 -0600
Subject: [PATCH 35/64] refactor: parse args

---
 src/parser.ts | 61 ++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 46 insertions(+), 15 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index ace05c0..239a72c 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -171,7 +171,17 @@ function parseExpression(body: Token[]): AST | null {
     if (!second) {
       return new Identifier(first.value)
     } else if (second.value === '(') {
-      const args: AST[] = [] // TODO: parse args
+      const args: VariableDeclaration[] = []
+      let i = 1
+
+      while (i < body.length) {
+        const line = readUntil(',', body, i)
+        i += line.length
+        if (line.at(-1)?.value === ',') line.pop() // skip ,
+
+        args.push(parseExpression(line) as VariableDeclaration)
+      }
+
       return new CallExpression(first.value, args)
     } else if (second.value === '.' || second.value === '[') {
       const third = body[2]
@@ -182,19 +192,6 @@ function parseExpression(body: Token[]): AST | null {
   return null
 }
 
-function parseFunction(): FunctionDeclaration {
-  const type = tokens[i - 1].value // TODO: remove backtrack hack
-  const name = tokens[i++].value
-  // TODO: parse args
-  const args = consumeUntil(')').slice(1, -1) as unknown as VariableDeclaration[]
-
-  let body = null
-  if (tokens[i].value === ';') i++ // skip ;
-  else body = parseBlock()
-
-  return new FunctionDeclaration(name, type, args, body)
-}
-
 function parseVariable(): VariableDeclaration {
   i-- // TODO: remove backtrack hack
   const qualifiers: string[] = []
@@ -212,6 +209,38 @@ function parseVariable(): VariableDeclaration {
   return new VariableDeclaration(name, type, value, qualifiers)
 }
 
+function parseFunction(): FunctionDeclaration {
+  const type = tokens[i - 1].value // TODO: remove backtrack hack
+  const name = tokens[i++].value
+  const args: VariableDeclaration[] = []
+
+  const header = consumeUntil(')').slice(1, -1)
+  let j = 0
+  while (j < header.length) {
+    const qualifiers: string[] = []
+    while (header[j] && header[j].type !== 'identifier') {
+      qualifiers.push(header[j++].value)
+    }
+    const type = qualifiers.pop()!
+
+    const line = readUntil(',', header, j)
+    j += line.length
+
+    const name = line.shift()!.value
+    if (line.at(-1)?.value === ',') line.pop() // skip ,
+
+    const value = parseExpression(line)
+
+    args.push(new VariableDeclaration(name, type, value, qualifiers))
+  }
+
+  let body = null
+  if (tokens[i].value === ';') i++ // skip ;
+  else body = parseBlock()
+
+  return new FunctionDeclaration(name, type, args, body)
+}
+
 function parseStruct(): StructDeclaration {
   const name = tokens[i++].value
   i++ // skip {
@@ -406,11 +435,13 @@ const glsl = /* glsl */ `
       //
   }
 
-  void method();
+  void method(const bool foo);
 
   void main() {
     gl_FragColor = vec4(1, 0, 0, 1); // red
   }
+
+  method(true);
 `
 
 console.log(glsl)

From 12e44e038b1b2aa5e6466336aad2f8c8ebd3a2da Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 11 Nov 2023 23:46:37 -0600
Subject: [PATCH 36/64] refactor: Type node for complex types

---
 src/ast.ts    | 21 ++++++++++++++++-----
 src/parser.ts |  7 ++++---
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index c18e148..a4727a1 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -12,14 +12,25 @@ export class Identifier extends Node {
   }
 }
 
-export class VariableDeclaration extends Node {
-  constructor(public name: string, public type: Node, public value: Node | null, public qualifiers: Node[]) {
+export class BlockStatement extends Node {
+  constructor(public body: Node[]) {
     super()
   }
 }
 
-export class BlockStatement extends Node {
-  constructor(public body: Node[]) {
+export class Type extends Node {
+  constructor(public name: string, public componentType: Type | null, public size: number | null) {
+    super()
+  }
+}
+
+export class VariableDeclaration extends Node {
+  constructor(
+    public name: string,
+    public type: Type | Identifier,
+    public value: Node | null,
+    public qualifiers: Node[],
+  ) {
     super()
   }
 }
@@ -27,7 +38,7 @@ export class BlockStatement extends Node {
 export class FunctionDeclaration extends Node {
   constructor(
     public name: string,
-    public type: Node | null,
+    public type: Type | Identifier,
     public args: VariableDeclaration[],
     public body: BlockStatement | null,
   ) {
diff --git a/src/parser.ts b/src/parser.ts
index 239a72c..436bf55 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,5 +1,6 @@
 import {
   type AST,
+  Type,
   Identifier,
   Literal,
   CallExpression,
@@ -198,7 +199,7 @@ function parseVariable(): VariableDeclaration {
   while (tokens[i] && tokens[i].type !== 'identifier') {
     qualifiers.push(tokens[i++].value)
   }
-  const type = qualifiers.pop()!
+  const type = new Type(qualifiers.pop()!, null, null)
 
   const body = consumeUntil(';') // TODO: comma-separated lists
   const name = body.shift()!.value
@@ -210,7 +211,7 @@ function parseVariable(): VariableDeclaration {
 }
 
 function parseFunction(): FunctionDeclaration {
-  const type = tokens[i - 1].value // TODO: remove backtrack hack
+  const type = new Type(tokens[i - 1].value, null, null) // TODO: remove backtrack hack
   const name = tokens[i++].value
   const args: VariableDeclaration[] = []
 
@@ -221,7 +222,7 @@ function parseFunction(): FunctionDeclaration {
     while (header[j] && header[j].type !== 'identifier') {
       qualifiers.push(header[j++].value)
     }
-    const type = qualifiers.pop()!
+    const type = new Type(qualifiers.pop()!, null, null)
 
     const line = readUntil(',', header, j)
     j += line.length

From 6aa441b29f69c94fbc7e616a1c95b7044f6f88ee Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sun, 12 Nov 2023 04:16:41 -0600
Subject: [PATCH 37/64] refactor: Type accepts optional parameters

---
 src/ast.ts    | 2 +-
 src/parser.ts | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index a4727a1..e525996 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -19,7 +19,7 @@ export class BlockStatement extends Node {
 }
 
 export class Type extends Node {
-  constructor(public name: string, public componentType: Type | null, public size: number | null) {
+  constructor(public name: string, public parameters: (Type | Literal | Identifier)[] | null) {
     super()
   }
 }
diff --git a/src/parser.ts b/src/parser.ts
index 436bf55..572be3f 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -199,7 +199,7 @@ function parseVariable(): VariableDeclaration {
   while (tokens[i] && tokens[i].type !== 'identifier') {
     qualifiers.push(tokens[i++].value)
   }
-  const type = new Type(qualifiers.pop()!, null, null)
+  const type = new Type(qualifiers.pop()!, null)
 
   const body = consumeUntil(';') // TODO: comma-separated lists
   const name = body.shift()!.value
@@ -211,7 +211,7 @@ function parseVariable(): VariableDeclaration {
 }
 
 function parseFunction(): FunctionDeclaration {
-  const type = new Type(tokens[i - 1].value, null, null) // TODO: remove backtrack hack
+  const type = new Type(tokens[i - 1].value, null) // TODO: remove backtrack hack
   const name = tokens[i++].value
   const args: VariableDeclaration[] = []
 
@@ -222,7 +222,7 @@ function parseFunction(): FunctionDeclaration {
     while (header[j] && header[j].type !== 'identifier') {
       qualifiers.push(header[j++].value)
     }
-    const type = new Type(qualifiers.pop()!, null, null)
+    const type = new Type(qualifiers.pop()!, null)
 
     const line = readUntil(',', header, j)
     j += line.length

From 7e66faa34a1baee550bbf8c5f2cd34a8224aa796 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sun, 12 Nov 2023 08:56:05 -0600
Subject: [PATCH 38/64] chore(tests): add GLSL expression coverage

---
 src/parser.ts        | 25 ++++++++----
 tests/parser.test.ts | 97 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 114 insertions(+), 8 deletions(-)
 create mode 100644 tests/parser.test.ts

diff --git a/src/parser.ts b/src/parser.ts
index 572be3f..273caca 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -172,21 +172,27 @@ function parseExpression(body: Token[]): AST | null {
     if (!second) {
       return new Identifier(first.value)
     } else if (second.value === '(') {
-      const args: VariableDeclaration[] = []
-      let i = 1
+      const callee = new Identifier(first.value)
+      const args: AST[] = []
+
+      body = body.slice(2, -1) // skip ()
+      let i = 0
 
       while (i < body.length) {
         const line = readUntil(',', body, i)
         i += line.length
         if (line.at(-1)?.value === ',') line.pop() // skip ,
 
-        args.push(parseExpression(line) as VariableDeclaration)
+        const arg = parseExpression(line)
+        if (arg) args.push(arg)
       }
 
-      return new CallExpression(first.value, args)
+      return new CallExpression(callee, args)
     } else if (second.value === '.' || second.value === '[') {
-      const third = body[2]
-      return new MemberExpression(first.value, third.value)
+      // TODO: CallExpression from accessor (e.g. array.length())
+      const object = new Identifier(first.value)
+      const property = parseExpression([body[2]])!
+      return new MemberExpression(object, property)
     }
   }
 
@@ -374,7 +380,9 @@ function parseStatements(): AST[] {
     if (statement) {
       body.push(statement)
     } else {
-      const expression = parseExpression([token, ...consumeUntil(';').slice(0, -1)])
+      const line = [token, ...consumeUntil(';')]
+      if (line[line.length - 1].value === ';') line.pop()
+      const expression = parseExpression(line)
       if (expression) body.push(expression)
     }
   }
@@ -393,13 +401,14 @@ function parseBlock(): BlockStatement {
  */
 export function parse(code: string): AST[] {
   // TODO: preserve
+  code = code.replace('#version 300 es', '')
   tokens = tokenize(code).filter((token) => token.type !== 'whitespace' && token.type !== 'comment')
   i = 0
 
   return parseStatements()
 }
 
-const glsl = /* glsl */ `
+const glsl = /* glsl */ `#version 300 es
   flat in mat4 test;
 
   struct foo {
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
new file mode 100644
index 0000000..fb5a8f5
--- /dev/null
+++ b/tests/parser.test.ts
@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'vitest'
+import {
+  parse,
+  Identifier,
+  Literal,
+  UnaryExpression,
+  BinaryExpression,
+  TernaryExpression,
+  CallExpression,
+  MemberExpression,
+} from 'shaderkit'
+
+describe('parser', () => {
+  describe('GLSL', () => {
+    it('parses identifiers', () => {
+      const identifier = parse('identifier')[0] as Identifier
+      expect(identifier).toBeInstanceOf(Identifier)
+      expect(identifier.value).toBe('identifier')
+    })
+
+    it('parses literals', () => {
+      for (const value of ['true', 'false', '0', '0.0']) {
+        const literal = parse(value)[0] as Literal
+        expect(literal).toBeInstanceOf(Literal)
+        expect(literal.value).toBe(value)
+      }
+    })
+
+    it('parses unary expressions', () => {
+      for (const operator of ['+', '-', '~', '!', '++', '--']) {
+        const left = parse(`0${operator}`)[0] as UnaryExpression
+        expect(left).toBeInstanceOf(UnaryExpression)
+        expect(left.operator).toBe(operator)
+        expect(left.argument).toBeInstanceOf(Literal)
+        expect((left.argument as Literal).value).toBe('0')
+
+        const right = parse(`${operator}1`)[0] as UnaryExpression
+        expect(right).toBeInstanceOf(UnaryExpression)
+        expect(right.operator).toBe(operator)
+        expect(right.argument).toBeInstanceOf(Literal)
+        expect((right.argument as Literal).value).toBe('1')
+      }
+    })
+
+    it('parses binary expressions', () => {
+      const expression = parse('0 == 1')[0] as BinaryExpression
+      expect(expression).toBeInstanceOf(BinaryExpression)
+      expect(expression.operator).toBe('==')
+      expect(expression.left).toBeInstanceOf(Literal)
+      expect((expression.left as Literal).value).toBe('0')
+      expect(expression.right).toBeInstanceOf(Literal)
+      expect((expression.right as Literal).value).toBe('1')
+    })
+
+    it('parses ternary expressions', () => {
+      const expression = parse('true ? 0 : 1')[0] as TernaryExpression
+      expect(expression).toBeInstanceOf(TernaryExpression)
+      expect(expression.test).toBeInstanceOf(Literal)
+      expect((expression.test as Literal).value).toBe('true')
+      expect(expression.consequent).toBeInstanceOf(Literal)
+      expect((expression.consequent as Literal).value).toBe('0')
+      expect(expression.alternate).toBeInstanceOf(Literal)
+      expect((expression.alternate as Literal).value).toBe('1')
+    })
+
+    it('parses call expressions', () => {
+      {
+        const expression = parse('main()')[0] as CallExpression
+        expect(expression).toBeInstanceOf(CallExpression)
+        expect(expression.callee).toBeInstanceOf(Identifier)
+        expect((expression.callee as Identifier).value).toBe('main')
+        expect(expression.args.length).toBe(0)
+      }
+
+      {
+        const expression = parse('all(true, false)')[0] as CallExpression
+        expect(expression).toBeInstanceOf(CallExpression)
+        expect(expression.callee).toBeInstanceOf(Identifier)
+        expect((expression.callee as Identifier).value).toBe('all')
+        expect(expression.args.length).toBe(2)
+        expect(expression.args[0]).toBeInstanceOf(Literal)
+        expect((expression.args[0] as Literal).value).toBe('true')
+        expect(expression.args[1]).toBeInstanceOf(Literal)
+        expect((expression.args[1] as Literal).value).toBe('false')
+      }
+    })
+
+    it('parses member expressions', () => {
+      const expression = parse('foo.bar')[0] as MemberExpression
+      expect(expression).toBeInstanceOf(MemberExpression)
+      expect(expression.object).toBeInstanceOf(Identifier)
+      expect((expression.object as Identifier).value).toBe('foo')
+      expect(expression.property).toBeInstanceOf(Identifier)
+      expect((expression.property as Identifier).value).toBe('bar')
+    })
+  })
+})

From 5f498710589908e145286f7bcfa8d70284ead73a Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sun, 12 Nov 2023 09:54:52 -0600
Subject: [PATCH 39/64] refactor: callexpr from accessor

---
 src/parser.ts        | 14 ++++++++++++--
 tests/parser.test.ts | 25 +++++++++++++++++++------
 2 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 273caca..bb3ee1a 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -189,10 +189,18 @@ function parseExpression(body: Token[]): AST | null {
 
       return new CallExpression(callee, args)
     } else if (second.value === '.' || second.value === '[') {
-      // TODO: CallExpression from accessor (e.g. array.length())
       const object = new Identifier(first.value)
       const property = parseExpression([body[2]])!
-      return new MemberExpression(object, property)
+      const left = new MemberExpression(object, property)
+
+      // e.g. array.length()
+      if (body[3]?.value === '(' && last.value === ')') {
+        const right = parseExpression(body.slice(2))! as CallExpression
+        right.callee = left
+        return right
+      }
+
+      return left
     }
   }
 
@@ -452,6 +460,8 @@ const glsl = /* glsl */ `#version 300 es
   }
 
   method(true);
+
+  foo.bar();
 `
 
 console.log(glsl)
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index fb5a8f5..bdd6437 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -86,12 +86,25 @@ describe('parser', () => {
     })
 
     it('parses member expressions', () => {
-      const expression = parse('foo.bar')[0] as MemberExpression
-      expect(expression).toBeInstanceOf(MemberExpression)
-      expect(expression.object).toBeInstanceOf(Identifier)
-      expect((expression.object as Identifier).value).toBe('foo')
-      expect(expression.property).toBeInstanceOf(Identifier)
-      expect((expression.property as Identifier).value).toBe('bar')
+      {
+        const expression = parse('foo.bar')[0] as MemberExpression
+        expect(expression).toBeInstanceOf(MemberExpression)
+        expect(expression.object).toBeInstanceOf(Identifier)
+        expect((expression.object as Identifier).value).toBe('foo')
+        expect(expression.property).toBeInstanceOf(Identifier)
+        expect((expression.property as Identifier).value).toBe('bar')
+      }
+
+      {
+        const expression = parse('array.length()')[0] as CallExpression
+        expect(expression).toBeInstanceOf(CallExpression)
+        expect(expression.callee).toBeInstanceOf(MemberExpression)
+        expect((expression.callee as MemberExpression).object).toBeInstanceOf(Identifier)
+        expect(((expression.callee as MemberExpression).object as Identifier).value).toBe('array')
+        expect((expression.callee as MemberExpression).property).toBeInstanceOf(Identifier)
+        expect(((expression.callee as MemberExpression).property as Identifier).value).toBe('length')
+        expect(expression.args.length).toBe(0)
+      }
     })
   })
 })

From ca16ea522fa4df27cdc451a0f0d6f6f5db038acc Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sun, 12 Nov 2023 11:13:25 -0600
Subject: [PATCH 40/64] chore: split up agnostic tests

---
 tests/parser.test.ts | 170 +++++++++++++++++++++----------------------
 1 file changed, 84 insertions(+), 86 deletions(-)

diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index bdd6437..b40dee7 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -11,100 +11,98 @@ import {
 } from 'shaderkit'
 
 describe('parser', () => {
-  describe('GLSL', () => {
-    it('parses identifiers', () => {
-      const identifier = parse('identifier')[0] as Identifier
-      expect(identifier).toBeInstanceOf(Identifier)
-      expect(identifier.value).toBe('identifier')
-    })
+  it('parses identifiers', () => {
+    const identifier = parse('identifier')[0] as Identifier
+    expect(identifier).toBeInstanceOf(Identifier)
+    expect(identifier.value).toBe('identifier')
+  })
 
-    it('parses literals', () => {
-      for (const value of ['true', 'false', '0', '0.0']) {
-        const literal = parse(value)[0] as Literal
-        expect(literal).toBeInstanceOf(Literal)
-        expect(literal.value).toBe(value)
-      }
-    })
+  it('parses literals', () => {
+    for (const value of ['true', 'false', '0', '0.0']) {
+      const literal = parse(value)[0] as Literal
+      expect(literal).toBeInstanceOf(Literal)
+      expect(literal.value).toBe(value)
+    }
+  })
 
-    it('parses unary expressions', () => {
-      for (const operator of ['+', '-', '~', '!', '++', '--']) {
-        const left = parse(`0${operator}`)[0] as UnaryExpression
-        expect(left).toBeInstanceOf(UnaryExpression)
-        expect(left.operator).toBe(operator)
-        expect(left.argument).toBeInstanceOf(Literal)
-        expect((left.argument as Literal).value).toBe('0')
+  it('parses unary expressions', () => {
+    for (const operator of ['+', '-', '~', '!', '++', '--']) {
+      const left = parse(`0${operator}`)[0] as UnaryExpression
+      expect(left).toBeInstanceOf(UnaryExpression)
+      expect(left.operator).toBe(operator)
+      expect(left.argument).toBeInstanceOf(Literal)
+      expect((left.argument as Literal).value).toBe('0')
 
-        const right = parse(`${operator}1`)[0] as UnaryExpression
-        expect(right).toBeInstanceOf(UnaryExpression)
-        expect(right.operator).toBe(operator)
-        expect(right.argument).toBeInstanceOf(Literal)
-        expect((right.argument as Literal).value).toBe('1')
-      }
-    })
+      const right = parse(`${operator}1`)[0] as UnaryExpression
+      expect(right).toBeInstanceOf(UnaryExpression)
+      expect(right.operator).toBe(operator)
+      expect(right.argument).toBeInstanceOf(Literal)
+      expect((right.argument as Literal).value).toBe('1')
+    }
+  })
 
-    it('parses binary expressions', () => {
-      const expression = parse('0 == 1')[0] as BinaryExpression
-      expect(expression).toBeInstanceOf(BinaryExpression)
-      expect(expression.operator).toBe('==')
-      expect(expression.left).toBeInstanceOf(Literal)
-      expect((expression.left as Literal).value).toBe('0')
-      expect(expression.right).toBeInstanceOf(Literal)
-      expect((expression.right as Literal).value).toBe('1')
-    })
+  it('parses binary expressions', () => {
+    const expression = parse('0 == 1')[0] as BinaryExpression
+    expect(expression).toBeInstanceOf(BinaryExpression)
+    expect(expression.operator).toBe('==')
+    expect(expression.left).toBeInstanceOf(Literal)
+    expect((expression.left as Literal).value).toBe('0')
+    expect(expression.right).toBeInstanceOf(Literal)
+    expect((expression.right as Literal).value).toBe('1')
+  })
 
-    it('parses ternary expressions', () => {
-      const expression = parse('true ? 0 : 1')[0] as TernaryExpression
-      expect(expression).toBeInstanceOf(TernaryExpression)
-      expect(expression.test).toBeInstanceOf(Literal)
-      expect((expression.test as Literal).value).toBe('true')
-      expect(expression.consequent).toBeInstanceOf(Literal)
-      expect((expression.consequent as Literal).value).toBe('0')
-      expect(expression.alternate).toBeInstanceOf(Literal)
-      expect((expression.alternate as Literal).value).toBe('1')
-    })
+  it('parses ternary expressions', () => {
+    const expression = parse('true ? 0 : 1')[0] as TernaryExpression
+    expect(expression).toBeInstanceOf(TernaryExpression)
+    expect(expression.test).toBeInstanceOf(Literal)
+    expect((expression.test as Literal).value).toBe('true')
+    expect(expression.consequent).toBeInstanceOf(Literal)
+    expect((expression.consequent as Literal).value).toBe('0')
+    expect(expression.alternate).toBeInstanceOf(Literal)
+    expect((expression.alternate as Literal).value).toBe('1')
+  })
 
-    it('parses call expressions', () => {
-      {
-        const expression = parse('main()')[0] as CallExpression
-        expect(expression).toBeInstanceOf(CallExpression)
-        expect(expression.callee).toBeInstanceOf(Identifier)
-        expect((expression.callee as Identifier).value).toBe('main')
-        expect(expression.args.length).toBe(0)
-      }
+  it('parses call expressions', () => {
+    {
+      const expression = parse('main()')[0] as CallExpression
+      expect(expression).toBeInstanceOf(CallExpression)
+      expect(expression.callee).toBeInstanceOf(Identifier)
+      expect((expression.callee as Identifier).value).toBe('main')
+      expect(expression.args.length).toBe(0)
+    }
 
-      {
-        const expression = parse('all(true, false)')[0] as CallExpression
-        expect(expression).toBeInstanceOf(CallExpression)
-        expect(expression.callee).toBeInstanceOf(Identifier)
-        expect((expression.callee as Identifier).value).toBe('all')
-        expect(expression.args.length).toBe(2)
-        expect(expression.args[0]).toBeInstanceOf(Literal)
-        expect((expression.args[0] as Literal).value).toBe('true')
-        expect(expression.args[1]).toBeInstanceOf(Literal)
-        expect((expression.args[1] as Literal).value).toBe('false')
-      }
-    })
+    {
+      const expression = parse('all(true, false)')[0] as CallExpression
+      expect(expression).toBeInstanceOf(CallExpression)
+      expect(expression.callee).toBeInstanceOf(Identifier)
+      expect((expression.callee as Identifier).value).toBe('all')
+      expect(expression.args.length).toBe(2)
+      expect(expression.args[0]).toBeInstanceOf(Literal)
+      expect((expression.args[0] as Literal).value).toBe('true')
+      expect(expression.args[1]).toBeInstanceOf(Literal)
+      expect((expression.args[1] as Literal).value).toBe('false')
+    }
+  })
 
-    it('parses member expressions', () => {
-      {
-        const expression = parse('foo.bar')[0] as MemberExpression
-        expect(expression).toBeInstanceOf(MemberExpression)
-        expect(expression.object).toBeInstanceOf(Identifier)
-        expect((expression.object as Identifier).value).toBe('foo')
-        expect(expression.property).toBeInstanceOf(Identifier)
-        expect((expression.property as Identifier).value).toBe('bar')
-      }
+  it('parses member expressions', () => {
+    {
+      const expression = parse('foo.bar')[0] as MemberExpression
+      expect(expression).toBeInstanceOf(MemberExpression)
+      expect(expression.object).toBeInstanceOf(Identifier)
+      expect((expression.object as Identifier).value).toBe('foo')
+      expect(expression.property).toBeInstanceOf(Identifier)
+      expect((expression.property as Identifier).value).toBe('bar')
+    }
 
-      {
-        const expression = parse('array.length()')[0] as CallExpression
-        expect(expression).toBeInstanceOf(CallExpression)
-        expect(expression.callee).toBeInstanceOf(MemberExpression)
-        expect((expression.callee as MemberExpression).object).toBeInstanceOf(Identifier)
-        expect(((expression.callee as MemberExpression).object as Identifier).value).toBe('array')
-        expect((expression.callee as MemberExpression).property).toBeInstanceOf(Identifier)
-        expect(((expression.callee as MemberExpression).property as Identifier).value).toBe('length')
-        expect(expression.args.length).toBe(0)
-      }
-    })
+    {
+      const expression = parse('array.length()')[0] as CallExpression
+      expect(expression).toBeInstanceOf(CallExpression)
+      expect(expression.callee).toBeInstanceOf(MemberExpression)
+      expect((expression.callee as MemberExpression).object).toBeInstanceOf(Identifier)
+      expect(((expression.callee as MemberExpression).object as Identifier).value).toBe('array')
+      expect((expression.callee as MemberExpression).property).toBeInstanceOf(Identifier)
+      expect(((expression.callee as MemberExpression).property as Identifier).value).toBe('length')
+      expect(expression.args.length).toBe(0)
+    }
   })
 })

From 2a216fa20f86418cc2a5487c9ef01f82b652bca7 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Mon, 13 Nov 2023 02:33:43 -0600
Subject: [PATCH 41/64] chore(tests): add GLSL statements coverage

---
 src/ast.ts           |   2 +-
 src/parser.ts        |   7 +-
 tests/parser.test.ts | 177 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 182 insertions(+), 4 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index e525996..234cd24 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -29,7 +29,7 @@ export class VariableDeclaration extends Node {
     public name: string,
     public type: Type | Identifier,
     public value: Node | null,
-    public qualifiers: Node[],
+    public qualifiers: string[],
   ) {
     super()
   }
diff --git a/src/parser.ts b/src/parser.ts
index bb3ee1a..f2a4be6 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -217,6 +217,7 @@ function parseVariable(): VariableDeclaration {
 
   const body = consumeUntil(';') // TODO: comma-separated lists
   const name = body.shift()!.value
+  body.shift() // skip =
   body.pop() // skip ;
 
   const value = parseExpression(body)
@@ -371,9 +372,7 @@ function parseStatements(): AST[] {
     let statement: AST | null = null
 
     if (token.type === 'keyword') {
-      if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
-      else if (isVariable(token.value) && tokens[i]?.value !== '(') statement = parseVariable()
-      else if (token.value === 'struct') statement = parseStruct()
+      if (token.value === 'struct') statement = parseStruct()
       else if (token.value === 'continue') (statement = new ContinueStatement()), i++
       else if (token.value === 'break') (statement = new BreakStatement()), i++
       else if (token.value === 'discard') (statement = new DiscardStatement()), i++
@@ -383,6 +382,8 @@ function parseStatements(): AST[] {
       else if (token.value === 'for') statement = parseFor()
       else if (token.value === 'do') statement = parseDoWhile()
       else if (token.value === 'switch') statement = parseSwitch()
+      else if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
+      else if (isVariable(token.value) && tokens[i]?.value !== '(') statement = parseVariable()
     }
 
     if (statement) {
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index b40dee7..e0fb480 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -3,11 +3,26 @@ import {
   parse,
   Identifier,
   Literal,
+  Type,
   UnaryExpression,
   BinaryExpression,
   TernaryExpression,
   CallExpression,
   MemberExpression,
+  VariableDeclaration,
+  StructDeclaration,
+  FunctionDeclaration,
+  BlockStatement,
+  ContinueStatement,
+  BreakStatement,
+  DiscardStatement,
+  ReturnStatement,
+  IfStatement,
+  WhileStatement,
+  ForStatement,
+  DoWhileStatement,
+  SwitchStatement,
+  SwitchCase,
 } from 'shaderkit'
 
 describe('parser', () => {
@@ -105,4 +120,166 @@ describe('parser', () => {
       expect(expression.args.length).toBe(0)
     }
   })
+
+  it('parses variable declarations', () => {
+    const statement = parse('const vec4 foo = vec4(0, 0, 0, 0);')[0] as VariableDeclaration
+    expect(statement).toBeInstanceOf(VariableDeclaration)
+    expect(statement.name).toBe('foo')
+    expect(statement.type).toBeInstanceOf(Type)
+    expect((statement.type as Type).name).toBe('vec4')
+    expect((statement.type as Type).parameters).toBe(null)
+    expect(statement.qualifiers.length).toBe(1)
+    expect(statement.qualifiers[0]).toBe('const')
+    expect(statement.value).toBeInstanceOf(CallExpression)
+
+    // TODO: comma-separated list
+  })
+
+  it('parses struct declarations', () => {
+    const statement = parse('struct foo { const bool bar = true; };')[0] as StructDeclaration
+    expect(statement).toBeInstanceOf(StructDeclaration)
+    expect(statement.name).toBe('foo')
+    expect(statement.members.length).toBe(1)
+    expect(statement.members[0].name).toBe('bar')
+    expect(statement.members[0].type).toBeInstanceOf(Type)
+    expect((statement.members[0].type as Type).name).toBe('bool')
+    expect((statement.members[0].type as Type).parameters).toBe(null)
+    expect(statement.members[0].qualifiers.length).toBe(1)
+    expect(statement.members[0].qualifiers[0]).toBe('const')
+    expect(statement.members[0].value).toBeInstanceOf(Literal)
+    expect((statement.members[0].value as Literal).value).toBe('true')
+  })
+
+  it('parses function declarations', () => {
+    {
+      const statement = parse('void main();')[0] as FunctionDeclaration
+      expect(statement).toBeInstanceOf(FunctionDeclaration)
+      expect(statement.name).toBe('main')
+      expect(statement.type).toBeInstanceOf(Type)
+      expect((statement.type as Type).name).toBe('void')
+      expect((statement.type as Type).parameters).toBe(null)
+      expect(statement.args.length).toBe(0)
+      expect(statement.body).toBe(null)
+    }
+
+    {
+      const statement = parse('void main(const bool enabled) {}')[0] as FunctionDeclaration
+      expect(statement).toBeInstanceOf(FunctionDeclaration)
+      expect(statement.name).toBe('main')
+      expect(statement.type).toBeInstanceOf(Type)
+      expect((statement.type as Type).name).toBe('void')
+      expect((statement.type as Type).parameters).toBe(null)
+      expect(statement.args[0]).toBeInstanceOf(VariableDeclaration)
+      expect((statement.args[0] as VariableDeclaration).name).toBe('enabled')
+      expect((statement.args[0] as VariableDeclaration).qualifiers.length).toBe(1)
+      expect((statement.args[0] as VariableDeclaration).qualifiers[0]).toBe('const')
+      expect((statement.args[0] as VariableDeclaration).type).toBeInstanceOf(Type)
+      expect(((statement.args[0] as VariableDeclaration).type as Type).name).toBe('bool')
+      expect(((statement.args[0] as VariableDeclaration).type as Type).parameters).toBe(null)
+      expect(statement.body).toBeInstanceOf(BlockStatement)
+      expect((statement.body as BlockStatement).body.length).toBe(0)
+    }
+  })
+
+  it('parses continue statements', () => {
+    const statement = parse('continue;')[0] as ContinueStatement
+    expect(statement).toBeInstanceOf(ContinueStatement)
+  })
+
+  it('parses break statements', () => {
+    const statement = parse('break;')[0] as BreakStatement
+    expect(statement).toBeInstanceOf(BreakStatement)
+  })
+
+  it('parses discard statements', () => {
+    const statement = parse('discard;')[0] as DiscardStatement
+    expect(statement).toBeInstanceOf(DiscardStatement)
+  })
+
+  it('parses return statements', () => {
+    {
+      const statement = parse('return;')[0] as ReturnStatement
+      expect(statement).toBeInstanceOf(ReturnStatement)
+      expect(statement.argument).toBe(null)
+    }
+
+    {
+      const statement = parse('return 0;')[0] as ReturnStatement
+      expect(statement).toBeInstanceOf(ReturnStatement)
+      expect(statement.argument).toBeInstanceOf(Literal)
+      expect((statement.argument as Literal).value).toBe('0')
+    }
+  })
+
+  it('parses if statements', () => {
+    const statement = parse('if (true) {} else if (false) {} else {}')[0] as IfStatement
+    expect(statement).toBeInstanceOf(IfStatement)
+    expect(statement.test).toBeInstanceOf(Literal)
+    expect((statement.test as Literal).value).toBe('true')
+    expect(statement.consequent).toBeInstanceOf(BlockStatement)
+    expect((statement.consequent as BlockStatement).body.length).toBe(0)
+    expect(statement.alternate).toBeInstanceOf(IfStatement)
+    expect((statement.alternate as IfStatement).test).toBeInstanceOf(Literal)
+    expect(((statement.alternate as IfStatement).test as Literal).value).toBe('false')
+    expect((statement.alternate as IfStatement).consequent).toBeInstanceOf(BlockStatement)
+    expect(((statement.alternate as IfStatement).consequent as BlockStatement).body.length).toBe(0)
+    expect((statement.alternate as IfStatement).alternate).toBeInstanceOf(BlockStatement)
+    expect(((statement.alternate as IfStatement).alternate as BlockStatement).body.length).toBe(0)
+  })
+
+  it('parses while statements', () => {
+    const statement = parse('while(true) {}')[0] as WhileStatement
+    expect(statement).toBeInstanceOf(WhileStatement)
+    expect(statement.test).toBeInstanceOf(Literal)
+    expect((statement.test as Literal).value).toBe('true')
+    expect(statement.body).toBeInstanceOf(BlockStatement)
+    expect((statement.body as BlockStatement).body.length).toBe(0)
+  })
+
+  it('parses for statements', () => {
+    const statement = parse('for (int 0 = 0; i < 1; i++) {}')[0] as ForStatement
+    expect(statement).toBeInstanceOf(ForStatement)
+    // TODO: this should be a VariableDeclaration
+    expect(statement.init).toBeInstanceOf(BinaryExpression)
+    expect((statement.init as BinaryExpression).operator).toBe('=')
+    expect(statement.test).toBeInstanceOf(BinaryExpression)
+    expect((statement.test as BinaryExpression).operator).toBe('<')
+    expect((statement.test as BinaryExpression).left).toBeInstanceOf(Identifier)
+    expect(((statement.test as BinaryExpression).left as Identifier).value).toBe('i')
+    expect((statement.test as BinaryExpression).right).toBeInstanceOf(Literal)
+    expect(((statement.test as BinaryExpression).right as Literal).value).toBe('1')
+    expect(statement.update).toBeInstanceOf(UnaryExpression)
+    expect((statement.update as UnaryExpression).operator).toBe('++')
+    expect((statement.update as UnaryExpression).argument).toBeInstanceOf(Identifier)
+    expect(((statement.update as UnaryExpression).argument as Identifier).value).toBe('i')
+    expect(statement.body).toBeInstanceOf(BlockStatement)
+    expect((statement.body as BlockStatement).body.length).toBe(0)
+  })
+
+  it('parses do-while statements', () => {
+    const statement = parse('do {} while(true);')[0] as DoWhileStatement
+    expect(statement).toBeInstanceOf(DoWhileStatement)
+    expect(statement.body).toBeInstanceOf(BlockStatement)
+    expect((statement.body as BlockStatement).body.length).toBe(0)
+    expect(statement.test).toBeInstanceOf(Literal)
+    expect((statement.test as Literal).value).toBe('true')
+  })
+
+  it('parses switch statements', () => {
+    // TODO: parse switch case scope
+    const statement = parse('switch(true) { case 0: break; default: discard; }')[0] as SwitchStatement
+    expect(statement).toBeInstanceOf(SwitchStatement)
+    expect(statement.discriminant).toBeInstanceOf(Literal)
+    expect((statement.discriminant as Literal).value).toBe('true')
+    expect(statement.cases.length).toBe(2)
+    expect(statement.cases[0]).toBeInstanceOf(SwitchCase)
+    expect((statement.cases[0] as SwitchCase).test).toBeInstanceOf(Literal)
+    expect(((statement.cases[0] as SwitchCase).test as Literal).value).toBe('0')
+    // expect((statement.cases[0] as SwitchCase).consequent.length).toBe(1)
+    // expect((statement.cases[0] as SwitchCase).consequent[0]).toBeInstanceOf(BreakStatement)
+    expect(statement.cases[1]).toBeInstanceOf(SwitchCase)
+    expect((statement.cases[1] as SwitchCase).test).toBe(null)
+    // expect((statement.cases[1] as SwitchCase).consequent.length).toBe(1)
+    // expect((statement.cases[0] as SwitchCase).consequent[0]).toBeInstanceOf(DiscardStatement)
+  })
 })

From a95ed6f639d02b483fabe88ee2e9d56bb2c88393 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Tue, 14 Nov 2023 05:39:42 -0600
Subject: [PATCH 42/64] refactor: parse for init as VariableDeclaration

---
 src/parser.ts        | 23 +++++++++--------------
 tests/parser.test.ts | 13 +++++++++----
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index f2a4be6..fbb3fcd 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -307,22 +307,17 @@ function parseWhile(): WhileStatement {
 }
 
 function parseFor(): ForStatement {
-  const tests: [init: Token[], test: Token[], update: Token[]] = [[], [], []]
-  let j = 0
+  const delimiterIndex = i + (readUntil(')', tokens, i).length - 1)
 
-  const loop = consumeUntil(')').slice(1, -1)
-  while (loop.length) {
-    const next = loop.shift()!
-    if (next.value === ';') {
-      j++
-    } else {
-      tests[j].push(next)
-    }
-  }
+  i++ // skip (
+  i++ // TODO: remove backtrack hack
+
+  const init = parseVariable()
+  const test = parseExpression(consumeUntil(';').slice(0, -1))
+  const update = parseExpression(tokens.slice(i, delimiterIndex))
 
-  const init = parseExpression(tests[0])
-  const test = parseExpression(tests[1])
-  const update = parseExpression(tests[2])
+  i = delimiterIndex
+  i++ // skip )
 
   const body = parseBlock()
 
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index e0fb480..636bcec 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -237,11 +237,16 @@ describe('parser', () => {
   })
 
   it('parses for statements', () => {
-    const statement = parse('for (int 0 = 0; i < 1; i++) {}')[0] as ForStatement
+    const statement = parse('for (int i = 0; i < 1; i++) {}')[0] as ForStatement
     expect(statement).toBeInstanceOf(ForStatement)
-    // TODO: this should be a VariableDeclaration
-    expect(statement.init).toBeInstanceOf(BinaryExpression)
-    expect((statement.init as BinaryExpression).operator).toBe('=')
+    expect(statement.init).toBeInstanceOf(VariableDeclaration)
+    expect((statement.init as VariableDeclaration).name).toBe('i')
+    expect((statement.init as VariableDeclaration).type).toBeInstanceOf(Type)
+    expect(((statement.init as VariableDeclaration).type as Type).name).toBe('int')
+    expect(((statement.init as VariableDeclaration).type as Type).parameters).toBe(null)
+    expect((statement.init as VariableDeclaration).value).toBeInstanceOf(Literal)
+    expect(((statement.init as VariableDeclaration).value as Literal).value).toBe('0')
+    expect((statement.init as VariableDeclaration).qualifiers.length).toBe(0)
     expect(statement.test).toBeInstanceOf(BinaryExpression)
     expect((statement.test as BinaryExpression).operator).toBe('<')
     expect((statement.test as BinaryExpression).left).toBeInstanceOf(Identifier)

From 11b81efaca85a5a2abdb8adcc88df04772a33753 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Tue, 14 Nov 2023 09:48:59 -0600
Subject: [PATCH 43/64] refactor: parse switch case scope

---
 src/parser.ts        | 28 ++++++++++++++++------------
 tests/parser.test.ts |  8 ++++----
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index fbb3fcd..c6d1f4a 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -335,19 +335,20 @@ function parseDoWhile(): DoWhileStatement {
 
 function parseSwitch(): SwitchStatement {
   const discriminant = parseExpression(consumeUntil(')'))
-  const body = consumeUntil('}').slice(1, -1)
+  const delimiterIndex = i + readUntil('}', tokens, i).length - 1
 
-  let j = -1
   const cases: SwitchCase[] = []
-  while (body.length) {
-    const token = body.shift()!
-    if (token.value === 'case' || token.value === 'default') {
-      const test = token.value === 'case' ? parseExpression([body.shift()!]) : null
-      cases.push(new SwitchCase(test, []))
-      j++
-    } else {
-      // TODO: parse scope
-      cases[j].consequent.push(token)
+  while (i < delimiterIndex) {
+    const token = tokens[i++]
+
+    if (token.value === 'case') {
+      const test = parseExpression(consumeUntil(':').slice(0, -1))
+      const consequent = parseStatements()
+      cases.push(new SwitchCase(test, consequent))
+    } else if (token.value === 'default') {
+      i++ // skip :
+      const consequent = parseStatements()
+      cases.push(new SwitchCase(null, consequent))
     }
   }
 
@@ -367,7 +368,10 @@ function parseStatements(): AST[] {
     let statement: AST | null = null
 
     if (token.type === 'keyword') {
-      if (token.value === 'struct') statement = parseStruct()
+      if (token.value === 'case' || token.value === 'default') {
+        i--
+        break
+      } else if (token.value === 'struct') statement = parseStruct()
       else if (token.value === 'continue') (statement = new ContinueStatement()), i++
       else if (token.value === 'break') (statement = new BreakStatement()), i++
       else if (token.value === 'discard') (statement = new DiscardStatement()), i++
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index 636bcec..5815adf 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -280,11 +280,11 @@ describe('parser', () => {
     expect(statement.cases[0]).toBeInstanceOf(SwitchCase)
     expect((statement.cases[0] as SwitchCase).test).toBeInstanceOf(Literal)
     expect(((statement.cases[0] as SwitchCase).test as Literal).value).toBe('0')
-    // expect((statement.cases[0] as SwitchCase).consequent.length).toBe(1)
-    // expect((statement.cases[0] as SwitchCase).consequent[0]).toBeInstanceOf(BreakStatement)
+    expect((statement.cases[0] as SwitchCase).consequent.length).toBe(1)
+    expect((statement.cases[0] as SwitchCase).consequent[0]).toBeInstanceOf(BreakStatement)
     expect(statement.cases[1]).toBeInstanceOf(SwitchCase)
     expect((statement.cases[1] as SwitchCase).test).toBe(null)
-    // expect((statement.cases[1] as SwitchCase).consequent.length).toBe(1)
-    // expect((statement.cases[0] as SwitchCase).consequent[0]).toBeInstanceOf(DiscardStatement)
+    expect((statement.cases[1] as SwitchCase).consequent.length).toBe(1)
+    expect((statement.cases[1] as SwitchCase).consequent[0]).toBeInstanceOf(DiscardStatement)
   })
 })

From 25729a52599710c91b46625876179d2e25676e01 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Tue, 14 Nov 2023 09:49:15 -0600
Subject: [PATCH 44/64] chore: cleanup

---
 tests/parser.test.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index 5815adf..b7f8e20 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -271,7 +271,6 @@ describe('parser', () => {
   })
 
   it('parses switch statements', () => {
-    // TODO: parse switch case scope
     const statement = parse('switch(true) { case 0: break; default: discard; }')[0] as SwitchStatement
     expect(statement).toBeInstanceOf(SwitchStatement)
     expect(statement.discriminant).toBeInstanceOf(Literal)

From 2444cbbe8fedf0a9e61ac24e8e60ef2067a54e81 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 16 Nov 2023 16:34:26 -0600
Subject: [PATCH 45/64] refactor: track unary handedness

---
 src/ast.ts           |  2 +-
 src/parser.ts        | 52 ++++++++++++++++++++++----------------------
 tests/parser.test.ts | 16 +++++++-------
 3 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 234cd24..2ef9d8a 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -107,7 +107,7 @@ export class StructDeclaration extends Node {
 }
 
 export class UnaryExpression extends Node {
-  constructor(public operator: string, public argument: Node) {
+  constructor(public operator: string, public left: Node | null, public right: Node | null) {
     super()
   }
 }
diff --git a/src/parser.ts b/src/parser.ts
index c6d1f4a..dfc7ee7 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -105,10 +105,35 @@ function consumeUntil(value: string): Token[] {
 function parseExpression(body: Token[]): AST | null {
   if (body.length === 0) return null
 
+  const first = body[0]
+  const last = body[body.length - 1]
+  if (UNARY_OPERATORS.includes(first.value)) {
+    const left = parseExpression(body.slice(1))!
+    return new UnaryExpression(first.value, left, null)
+  } else if (UNARY_OPERATORS.includes(last.value)) {
+    const right = parseExpression(body.slice(0, body.length - 1))!
+    return new UnaryExpression(last.value, null, right)
+  }
+
+  if (first.value === '(') {
+    const leftBody = readUntil(')', body)
+    const left = parseExpression(leftBody.slice(1, leftBody.length - 1))!
+
+    const operator = body[leftBody.length]
+    if (operator) {
+      const rightBody = body.slice(leftBody.length + 1)
+      const right = parseExpression(rightBody)!
+
+      return new BinaryExpression(operator.value, left, right)
+    }
+
+    return left
+  }
+
   let scopeIndex = 0
 
   for (const operator of BINARY_OPERATORS) {
-    for (let i = 1; i < body.length - 1; i++) {
+    for (let i = 0; i < body.length; i++) {
       const token = body[i]
       if (token.type !== 'symbol') continue
 
@@ -139,31 +164,6 @@ function parseExpression(body: Token[]): AST | null {
     }
   }
 
-  const first = body[0]
-  const last = body[body.length - 1]
-  if (UNARY_OPERATORS.includes(first.value)) {
-    const right = parseExpression(body.slice(1))!
-    return new UnaryExpression(first.value, right)
-  } else if (UNARY_OPERATORS.includes(last.value)) {
-    const argument = parseExpression(body.slice(0, body.length - 1))!
-    return new UnaryExpression(last.value, argument)
-  }
-
-  if (first.value === '(') {
-    const leftBody = readUntil(')', body)
-    const left = parseExpression(leftBody.slice(1, leftBody.length - 1))!
-
-    const operator = body[leftBody.length]
-    if (operator) {
-      const rightBody = body.slice(leftBody.length + 1)
-      const right = parseExpression(rightBody)!
-
-      return new BinaryExpression(operator.value, left, right)
-    }
-
-    return left
-  }
-
   if (first.type === 'bool' || first.type === 'int' || first.type === 'float') {
     return new Literal(first.value)
   } else if (first.type === 'identifier' || first.type === 'keyword') {
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index b7f8e20..dacb2ee 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -42,17 +42,17 @@ describe('parser', () => {
 
   it('parses unary expressions', () => {
     for (const operator of ['+', '-', '~', '!', '++', '--']) {
-      const left = parse(`0${operator}`)[0] as UnaryExpression
+      const left = parse(`${operator}0`)[0] as UnaryExpression
       expect(left).toBeInstanceOf(UnaryExpression)
       expect(left.operator).toBe(operator)
-      expect(left.argument).toBeInstanceOf(Literal)
-      expect((left.argument as Literal).value).toBe('0')
+      expect(left.left).toBeInstanceOf(Literal)
+      expect((left.left as Literal).value).toBe('0')
 
-      const right = parse(`${operator}1`)[0] as UnaryExpression
+      const right = parse(`1${operator}`)[0] as UnaryExpression
       expect(right).toBeInstanceOf(UnaryExpression)
       expect(right.operator).toBe(operator)
-      expect(right.argument).toBeInstanceOf(Literal)
-      expect((right.argument as Literal).value).toBe('1')
+      expect(right.right).toBeInstanceOf(Literal)
+      expect((right.right as Literal).value).toBe('1')
     }
   })
 
@@ -255,8 +255,8 @@ describe('parser', () => {
     expect(((statement.test as BinaryExpression).right as Literal).value).toBe('1')
     expect(statement.update).toBeInstanceOf(UnaryExpression)
     expect((statement.update as UnaryExpression).operator).toBe('++')
-    expect((statement.update as UnaryExpression).argument).toBeInstanceOf(Identifier)
-    expect(((statement.update as UnaryExpression).argument as Identifier).value).toBe('i')
+    expect((statement.update as UnaryExpression).right).toBeInstanceOf(Identifier)
+    expect(((statement.update as UnaryExpression).right as Identifier).value).toBe('i')
     expect(statement.body).toBeInstanceOf(BlockStatement)
     expect((statement.body as BlockStatement).body.length).toBe(0)
   })

From d0e3ac905665d56a18874d55e89b27d130cbec08 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 16 Nov 2023 16:52:08 -0600
Subject: [PATCH 46/64] feat: generator (GLSL)

---
 src/generator.ts | 111 +++++++++++++++++++++++++++++++++++++++++++++++
 src/parser.ts    |   6 ++-
 2 files changed, 116 insertions(+), 1 deletion(-)
 create mode 100644 src/generator.ts

diff --git a/src/generator.ts b/src/generator.ts
new file mode 100644
index 0000000..af1ed2a
--- /dev/null
+++ b/src/generator.ts
@@ -0,0 +1,111 @@
+import {
+  type AST,
+  Literal,
+  Identifier,
+  Type,
+  BlockStatement,
+  VariableDeclaration,
+  FunctionDeclaration,
+  CallExpression,
+  MemberExpression,
+  ArrayExpression,
+  IfStatement,
+  WhileStatement,
+  ForStatement,
+  DoWhileStatement,
+  SwitchStatement,
+  SwitchCase,
+  StructDeclaration,
+  UnaryExpression,
+  BinaryExpression,
+  TernaryExpression,
+  ReturnStatement,
+  ContinueStatement,
+  BreakStatement,
+  DiscardStatement,
+} from './ast'
+
+const EOL_REGEX = /\n$/
+
+// Punctuates expression statements
+function punctuate(line: string): string {
+  if (!line.endsWith('\n')) line = line + ';\n'
+  return line
+}
+
+// TODO: GLSL-only
+function format(node: AST | null): string {
+  let line = ''
+
+  if (node instanceof Literal || node instanceof Identifier) {
+    line = node.value
+  } else if (node instanceof Type) {
+    line = node.parameters ? `${node.name}<${node.parameters.map(format).join(', ')}>` : node.name
+  } else if (node instanceof BlockStatement) {
+    line = `{\n${node.body.map((node) => '  ' + punctuate(format(node))).join('')}}\n`
+  } else if (node instanceof VariableDeclaration) {
+    const value = node.value ? ` = ${format(node.value)}` : ''
+    line = `${node.qualifiers.join(' ')} ${format(node.type)} ${node.name}${value};\n`.trimStart()
+  } else if (node instanceof FunctionDeclaration) {
+    const args = node.args.map((node) => format(node).replace(';\n', '')).join(', ')
+    const body = node.body ? ` ${format(node.body)}` : ';\n'
+    line = `${format(node.type)} ${node.name}(${args})${body}`
+  } else if (node instanceof CallExpression) {
+    line = `${format(node.callee)}(${node.args.map(format).join(', ')})`
+  } else if (node instanceof MemberExpression) {
+    line = `${format(node.object)}.${format(node.property)}`
+  } else if (node instanceof ArrayExpression) {
+    // TODO
+  } else if (node instanceof IfStatement) {
+    const consequent = format(node.consequent).replace(EOL_REGEX, '')
+    const alternate = node.alternate ? ` else ${format(node.alternate).replace(EOL_REGEX, '')}` : ''
+    line = `if (${format(node.test)}) ${consequent}${alternate}\n`
+  } else if (node instanceof WhileStatement) {
+    line = `while (${format(node.test)}) ${format(node.body)}`
+  } else if (node instanceof ForStatement) {
+    const init = format(node.init).replace(';\n', '')
+    line = `for (${init}; ${format(node.test)}; ${format(node.update)}) ${format(node.body)}`
+  } else if (node instanceof DoWhileStatement) {
+    line = `do ${format(node.body).replace(EOL_REGEX, '')} while (${format(node.test)});\n`
+  } else if (node instanceof SwitchStatement) {
+    line = `switch(${format(node.discriminant)}) {\n${node.cases.map(format).join('')}}\n`
+  } else if (node instanceof SwitchCase) {
+    const header = node.test ? `case ${format(node.test)}:` : 'default:'
+    line = `  ${header}\n${node.consequent.map((node) => `    ${punctuate(format(node))}`).join('')}`
+  } else if (node instanceof StructDeclaration) {
+    line = `struct ${node.name} {\n${node.members.map((node) => `  ${format(node)}`).join('')}};\n`
+  } else if (node instanceof UnaryExpression) {
+    line = node.left ? `${format(node.left)}${node.operator}` : `${node.operator}${format(node.right)}`
+  } else if (node instanceof BinaryExpression) {
+    line = `${format(node.left)} ${node.operator} ${format(node.right)}`
+  } else if (node instanceof TernaryExpression) {
+    line = `${format(node.test)} ? ${format(node.consequent)} : ${format(node.alternate)}`
+  } else if (node instanceof ReturnStatement) {
+    line = node.argument ? `return ${format(node.argument)};\n` : `return;\n`
+  } else if (node instanceof ContinueStatement) {
+    line = 'continue;\n'
+  } else if (node instanceof BreakStatement) {
+    line = 'break;\n'
+  } else if (node instanceof DiscardStatement) {
+    line = 'discard;\n'
+  }
+
+  return line
+}
+
+export interface GenerateOptions {
+  target: 'GLSL' | 'WGSL'
+}
+
+/**
+ * Generates a string of GLSL or WGSL code from an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
+ */
+export function generate(ast: AST[], options: GenerateOptions): string {
+  let code = '#version 300 es\n'
+
+  for (let i = 0; i < ast.length; i++) {
+    code += punctuate(format(ast[i]))
+  }
+
+  return code
+}
diff --git a/src/parser.ts b/src/parser.ts
index dfc7ee7..504f8dd 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -23,6 +23,7 @@ import {
   SwitchCase,
   StructDeclaration,
 } from './ast'
+import { generate } from './generator'
 import { type Token, tokenize } from './tokenizer'
 
 const UNARY_OPERATORS = ['+', '-', '~', '!', '++', '--']
@@ -465,4 +466,7 @@ const glsl = /* glsl */ `#version 300 es
 `
 
 console.log(glsl)
-console.log(...parse(glsl))
+const ast = parse(glsl)
+console.log(...ast)
+
+console.log(generate(ast, { target: 'GLSL' }))

From 3ac993b128e9b31aa83180297c26a2abd28ddafb Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 16 Nov 2023 23:32:40 -0600
Subject: [PATCH 47/64] refactor: fix unary handedness

---
 src/parser.ts        | 8 ++++----
 tests/parser.test.ts | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 504f8dd..ad73b95 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -109,11 +109,11 @@ function parseExpression(body: Token[]): AST | null {
   const first = body[0]
   const last = body[body.length - 1]
   if (UNARY_OPERATORS.includes(first.value)) {
-    const left = parseExpression(body.slice(1))!
-    return new UnaryExpression(first.value, left, null)
+    const right = parseExpression(body.slice(1))!
+    return new UnaryExpression(first.value, null, right)
   } else if (UNARY_OPERATORS.includes(last.value)) {
-    const right = parseExpression(body.slice(0, body.length - 1))!
-    return new UnaryExpression(last.value, null, right)
+    const left = parseExpression(body.slice(0, body.length - 1))!
+    return new UnaryExpression(last.value, left, null)
   }
 
   if (first.value === '(') {
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index dacb2ee..a3d5a4e 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -42,13 +42,13 @@ describe('parser', () => {
 
   it('parses unary expressions', () => {
     for (const operator of ['+', '-', '~', '!', '++', '--']) {
-      const left = parse(`${operator}0`)[0] as UnaryExpression
+      const left = parse(`0${operator}`)[0] as UnaryExpression
       expect(left).toBeInstanceOf(UnaryExpression)
       expect(left.operator).toBe(operator)
       expect(left.left).toBeInstanceOf(Literal)
       expect((left.left as Literal).value).toBe('0')
 
-      const right = parse(`1${operator}`)[0] as UnaryExpression
+      const right = parse(`${operator}1`)[0] as UnaryExpression
       expect(right).toBeInstanceOf(UnaryExpression)
       expect(right.operator).toBe(operator)
       expect(right.right).toBeInstanceOf(Literal)
@@ -255,8 +255,8 @@ describe('parser', () => {
     expect(((statement.test as BinaryExpression).right as Literal).value).toBe('1')
     expect(statement.update).toBeInstanceOf(UnaryExpression)
     expect((statement.update as UnaryExpression).operator).toBe('++')
-    expect((statement.update as UnaryExpression).right).toBeInstanceOf(Identifier)
-    expect(((statement.update as UnaryExpression).right as Identifier).value).toBe('i')
+    expect((statement.update as UnaryExpression).left).toBeInstanceOf(Identifier)
+    expect(((statement.update as UnaryExpression).left as Identifier).value).toBe('i')
     expect(statement.body).toBeInstanceOf(BlockStatement)
     expect((statement.body as BlockStatement).body.length).toBe(0)
   })

From 23451f7006d3336357827bcdb8b7266e351c392d Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Thu, 16 Nov 2023 23:42:53 -0600
Subject: [PATCH 48/64] chore: cleanup empty block scope

---
 src/generator.ts | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/generator.ts b/src/generator.ts
index af1ed2a..570bd28 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -42,7 +42,8 @@ function format(node: AST | null): string {
   } else if (node instanceof Type) {
     line = node.parameters ? `${node.name}<${node.parameters.map(format).join(', ')}>` : node.name
   } else if (node instanceof BlockStatement) {
-    line = `{\n${node.body.map((node) => '  ' + punctuate(format(node))).join('')}}\n`
+    const cr = node.body.length ? '\n' : ''
+    line = `{${cr}${node.body.map((node) => '  ' + punctuate(format(node))).join('')}}\n`
   } else if (node instanceof VariableDeclaration) {
     const value = node.value ? ` = ${format(node.value)}` : ''
     line = `${node.qualifiers.join(' ')} ${format(node.type)} ${node.name}${value};\n`.trimStart()
@@ -68,12 +69,14 @@ function format(node: AST | null): string {
   } else if (node instanceof DoWhileStatement) {
     line = `do ${format(node.body).replace(EOL_REGEX, '')} while (${format(node.test)});\n`
   } else if (node instanceof SwitchStatement) {
-    line = `switch(${format(node.discriminant)}) {\n${node.cases.map(format).join('')}}\n`
+    const cr = node.cases.length ? '\n' : ''
+    line = `switch(${format(node.discriminant)}) {${cr}${node.cases.map(format).join('')}}\n`
   } else if (node instanceof SwitchCase) {
     const header = node.test ? `case ${format(node.test)}:` : 'default:'
     line = `  ${header}\n${node.consequent.map((node) => `    ${punctuate(format(node))}`).join('')}`
   } else if (node instanceof StructDeclaration) {
-    line = `struct ${node.name} {\n${node.members.map((node) => `  ${format(node)}`).join('')}};\n`
+    const cr = node.members.length ? '\n' : ''
+    line = `struct ${node.name} {${cr}${node.members.map((node) => `  ${format(node)}`).join('')}};\n`
   } else if (node instanceof UnaryExpression) {
     line = node.left ? `${format(node.left)}${node.operator}` : `${node.operator}${format(node.right)}`
   } else if (node instanceof BinaryExpression) {

From 2238f4e0b7f604a252d1dd3f56dc601a7ccf028d Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Fri, 17 Nov 2023 05:38:21 -0600
Subject: [PATCH 49/64] refactor: precision statements

---
 src/ast.ts           |  6 ++++++
 src/generator.ts     |  3 +++
 src/parser.ts        | 11 +++++++++++
 tests/parser.test.ts | 10 ++++++++++
 4 files changed, 30 insertions(+)

diff --git a/src/ast.ts b/src/ast.ts
index 2ef9d8a..c62e4fb 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -136,6 +136,12 @@ export class BreakStatement extends Node {}
 
 export class DiscardStatement extends Node {}
 
+export class PrecisionStatement extends Node {
+  constructor(public precision: 'lowp' | 'mediump' | 'highp', public type: Type) {
+    super()
+  }
+}
+
 export type AST =
   | Literal
   | Identifier
diff --git a/src/generator.ts b/src/generator.ts
index 570bd28..f7fe144 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -20,6 +20,7 @@ import {
   BinaryExpression,
   TernaryExpression,
   ReturnStatement,
+  PrecisionStatement,
   ContinueStatement,
   BreakStatement,
   DiscardStatement,
@@ -85,6 +86,8 @@ function format(node: AST | null): string {
     line = `${format(node.test)} ? ${format(node.consequent)} : ${format(node.alternate)}`
   } else if (node instanceof ReturnStatement) {
     line = node.argument ? `return ${format(node.argument)};\n` : `return;\n`
+  } else if (node instanceof PrecisionStatement) {
+    line = `precision ${node.precision} ${node.type.name};\n`
   } else if (node instanceof ContinueStatement) {
     line = 'continue;\n'
   } else if (node instanceof BreakStatement) {
diff --git a/src/parser.ts b/src/parser.ts
index ad73b95..4b35185 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -22,6 +22,7 @@ import {
   SwitchStatement,
   SwitchCase,
   StructDeclaration,
+  PrecisionStatement,
 } from './ast'
 import { generate } from './generator'
 import { type Token, tokenize } from './tokenizer'
@@ -356,6 +357,13 @@ function parseSwitch(): SwitchStatement {
   return new SwitchStatement(discriminant!, cases)
 }
 
+function parsePrecision(): PrecisionStatement {
+  const precision = tokens[i++].value
+  const type = new Type(tokens[i++].value, null)
+  i++ // skip ;
+  return new PrecisionStatement(precision as any, type)
+}
+
 function parseStatements(): AST[] {
   const body: AST[] = []
   let scopeIndex = 0
@@ -382,6 +390,7 @@ function parseStatements(): AST[] {
       else if (token.value === 'for') statement = parseFor()
       else if (token.value === 'do') statement = parseDoWhile()
       else if (token.value === 'switch') statement = parseSwitch()
+      else if (token.value === 'precision') statement = parsePrecision()
       else if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
       else if (isVariable(token.value) && tokens[i]?.value !== '(') statement = parseVariable()
     }
@@ -418,6 +427,8 @@ export function parse(code: string): AST[] {
 }
 
 const glsl = /* glsl */ `#version 300 es
+  precision highp float;
+
   flat in mat4 test;
 
   struct foo {
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index a3d5a4e..53db98f 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -23,6 +23,7 @@ import {
   DoWhileStatement,
   SwitchStatement,
   SwitchCase,
+  PrecisionStatement,
 } from 'shaderkit'
 
 describe('parser', () => {
@@ -286,4 +287,13 @@ describe('parser', () => {
     expect((statement.cases[1] as SwitchCase).consequent.length).toBe(1)
     expect((statement.cases[1] as SwitchCase).consequent[0]).toBeInstanceOf(DiscardStatement)
   })
+
+  it('parses precision statements', () => {
+    const statement = parse('precision highp float;')[0] as PrecisionStatement
+    expect(statement).toBeInstanceOf(PrecisionStatement)
+    expect(statement.precision).toBe('highp')
+    expect(statement.type).toBeInstanceOf(Type)
+    expect(statement.type.name).toBe('float')
+    expect(statement.type.parameters).toBe(null)
+  })
 })

From 5a619a353955e9b2f59d932227b073568cf7528e Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Fri, 17 Nov 2023 06:01:54 -0600
Subject: [PATCH 50/64] refactor: layout qualifiers

---
 src/ast.ts           |  1 +
 src/parser.ts        | 34 ++++++++++++++++++++++++++++++----
 tests/parser.test.ts | 40 +++++++++++++++++++++++++++++++---------
 3 files changed, 62 insertions(+), 13 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index c62e4fb..4411114 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -30,6 +30,7 @@ export class VariableDeclaration extends Node {
     public type: Type | Identifier,
     public value: Node | null,
     public qualifiers: string[],
+    public layout: Record<string, string | boolean> | null,
   ) {
     super()
   }
diff --git a/src/parser.ts b/src/parser.ts
index 4b35185..abb6e1f 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -211,6 +211,31 @@ function parseExpression(body: Token[]): AST | null {
 
 function parseVariable(): VariableDeclaration {
   i-- // TODO: remove backtrack hack
+
+  let layout: Record<string, string | boolean> | null = null
+  if (tokens[i].value === 'layout') {
+    layout = {}
+
+    i++ // skip layout
+
+    let key: string | null = null
+    while (tokens[i] && tokens[i].value !== ')') {
+      const token = tokens[i++]
+
+      if (token.value === ',') key = null
+      if (token.type === 'symbol') continue
+
+      if (!key) {
+        key = token.value
+        layout[key] = true
+      } else {
+        layout[key] = token.value
+      }
+    }
+
+    i++ // skip )
+  }
+
   const qualifiers: string[] = []
   while (tokens[i] && tokens[i].type !== 'identifier') {
     qualifiers.push(tokens[i++].value)
@@ -224,7 +249,7 @@ function parseVariable(): VariableDeclaration {
 
   const value = parseExpression(body)
 
-  return new VariableDeclaration(name, type, value, qualifiers)
+  return new VariableDeclaration(name, type, value, qualifiers, layout)
 }
 
 function parseFunction(): FunctionDeclaration {
@@ -249,7 +274,7 @@ function parseFunction(): FunctionDeclaration {
 
     const value = parseExpression(line)
 
-    args.push(new VariableDeclaration(name, type, value, qualifiers))
+    args.push(new VariableDeclaration(name, type, value, qualifiers, null))
   }
 
   let body = null
@@ -392,7 +417,8 @@ function parseStatements(): AST[] {
       else if (token.value === 'switch') statement = parseSwitch()
       else if (token.value === 'precision') statement = parsePrecision()
       else if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
-      else if (isVariable(token.value) && tokens[i]?.value !== '(') statement = parseVariable()
+      else if (token.value === 'layout' || (isVariable(token.value) && tokens[i]?.value !== '('))
+        statement = parseVariable()
     }
 
     if (statement) {
@@ -429,7 +455,7 @@ export function parse(code: string): AST[] {
 const glsl = /* glsl */ `#version 300 es
   precision highp float;
 
-  flat in mat4 test;
+  layout(location = 0, component = 1) flat in mat4 test;
 
   struct foo {
     bool isStruct;
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index 53db98f..da1a13a 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -123,15 +123,37 @@ describe('parser', () => {
   })
 
   it('parses variable declarations', () => {
-    const statement = parse('const vec4 foo = vec4(0, 0, 0, 0);')[0] as VariableDeclaration
-    expect(statement).toBeInstanceOf(VariableDeclaration)
-    expect(statement.name).toBe('foo')
-    expect(statement.type).toBeInstanceOf(Type)
-    expect((statement.type as Type).name).toBe('vec4')
-    expect((statement.type as Type).parameters).toBe(null)
-    expect(statement.qualifiers.length).toBe(1)
-    expect(statement.qualifiers[0]).toBe('const')
-    expect(statement.value).toBeInstanceOf(CallExpression)
+    {
+      const statement = parse('const vec4 foo = vec4(0, 0, 0, 0);')[0] as VariableDeclaration
+      expect(statement).toBeInstanceOf(VariableDeclaration)
+      expect(statement.name).toBe('foo')
+      expect(statement.type).toBeInstanceOf(Type)
+      expect((statement.type as Type).name).toBe('vec4')
+      expect((statement.type as Type).parameters).toBe(null)
+      expect(statement.qualifiers.length).toBe(1)
+      expect(statement.qualifiers[0]).toBe('const')
+      expect(statement.value).toBeInstanceOf(CallExpression)
+    }
+
+    {
+      const statement = parse(
+        ' layout(location = 0, component = 1, column_major) flat in mat4 test;',
+      )[0] as VariableDeclaration
+      expect(statement).toBeInstanceOf(VariableDeclaration)
+      expect(statement.name).toBe('test')
+      expect(statement.type).toBeInstanceOf(Type)
+      expect((statement.type as Type).name).toBe('mat4')
+      expect((statement.type as Type).parameters).toBe(null)
+      expect(statement.qualifiers.length).toBe(2)
+      expect(statement.qualifiers[0]).toBe('flat')
+      expect(statement.qualifiers[1]).toBe('in')
+      expect(statement.value).toBe(null)
+      expect(statement.layout).not.toBe(null)
+      expect(Object.keys(statement.layout as object).length).toBe(3)
+      expect((statement.layout as any).location).toBe('0')
+      expect((statement.layout as any).component).toBe('1')
+      expect((statement.layout as any).column_major).toBe(true)
+    }
 
     // TODO: comma-separated list
   })

From 6eac36937607df8df7c96256061dd9adbf2c8e11 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Fri, 17 Nov 2023 09:47:23 -0600
Subject: [PATCH 51/64] refactor: method type qualifiers

---
 src/ast.ts           |  1 +
 src/parser.ts        | 88 +++++++++++++++++++++++++-------------------
 tests/parser.test.ts |  7 +++-
 3 files changed, 56 insertions(+), 40 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 4411114..7bb9f5d 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -40,6 +40,7 @@ export class FunctionDeclaration extends Node {
   constructor(
     public name: string,
     public type: Type | Identifier,
+    public qualifiers: string[],
     public args: VariableDeclaration[],
     public body: BlockStatement | null,
   ) {
diff --git a/src/parser.ts b/src/parser.ts
index abb6e1f..62bb251 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -69,7 +69,7 @@ const TYPE_REGEX = /void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?/
 const QUALIFIER_REGEX = /in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp/
 const VARIABLE_REGEX = new RegExp(`${TYPE_REGEX.source}|${QUALIFIER_REGEX.source}|const|uniform`)
 
-const isVariable = RegExp.prototype.test.bind(VARIABLE_REGEX)
+const isDeclaration = RegExp.prototype.test.bind(VARIABLE_REGEX)
 
 const isOpen = RegExp.prototype.test.bind(/^[\(\[\{]$/)
 const isClose = RegExp.prototype.test.bind(/^[\)\]\}]$/)
@@ -209,38 +209,13 @@ function parseExpression(body: Token[]): AST | null {
   return null
 }
 
-function parseVariable(): VariableDeclaration {
+function parseVariable(
+  qualifiers: string[] = [],
+  layout: Record<string, string | boolean> | null = null,
+): VariableDeclaration {
   i-- // TODO: remove backtrack hack
 
-  let layout: Record<string, string | boolean> | null = null
-  if (tokens[i].value === 'layout') {
-    layout = {}
-
-    i++ // skip layout
-
-    let key: string | null = null
-    while (tokens[i] && tokens[i].value !== ')') {
-      const token = tokens[i++]
-
-      if (token.value === ',') key = null
-      if (token.type === 'symbol') continue
-
-      if (!key) {
-        key = token.value
-        layout[key] = true
-      } else {
-        layout[key] = token.value
-      }
-    }
-
-    i++ // skip )
-  }
-
-  const qualifiers: string[] = []
-  while (tokens[i] && tokens[i].type !== 'identifier') {
-    qualifiers.push(tokens[i++].value)
-  }
-  const type = new Type(qualifiers.pop()!, null)
+  const type = new Type(tokens[i++].value, null)
 
   const body = consumeUntil(';') // TODO: comma-separated lists
   const name = body.shift()!.value
@@ -252,11 +227,14 @@ function parseVariable(): VariableDeclaration {
   return new VariableDeclaration(name, type, value, qualifiers, layout)
 }
 
-function parseFunction(): FunctionDeclaration {
-  const type = new Type(tokens[i - 1].value, null) // TODO: remove backtrack hack
+function parseFunction(qualifiers: string[]): FunctionDeclaration {
+  i-- // TODO: remove backtrack hack
+
+  const type = new Type(tokens[i++].value, null)
   const name = tokens[i++].value
   const args: VariableDeclaration[] = []
 
+  // TODO: merge with parseVariable
   const header = consumeUntil(')').slice(1, -1)
   let j = 0
   while (j < header.length) {
@@ -281,7 +259,43 @@ function parseFunction(): FunctionDeclaration {
   if (tokens[i].value === ';') i++ // skip ;
   else body = parseBlock()
 
-  return new FunctionDeclaration(name, type, args, body)
+  return new FunctionDeclaration(name, type, qualifiers, args, body)
+}
+
+function parseIndeterminate(): VariableDeclaration | FunctionDeclaration {
+  i-- // TODO: remove backtrack hack
+
+  let layout: Record<string, string | boolean> | null = null
+  if (tokens[i].value === 'layout') {
+    i++ // skip layout
+
+    layout = {}
+
+    let key: string | null = null
+    while (tokens[i] && tokens[i].value !== ')') {
+      const token = tokens[i++]
+
+      if (token.value === ',') key = null
+      if (token.type === 'symbol') continue
+
+      if (!key) {
+        key = token.value
+        layout[key] = true
+      } else {
+        layout[key] = token.value
+      }
+    }
+
+    i++ // skip )
+  }
+
+  const qualifiers: string[] = []
+  while (tokens[i] && tokens[i].type !== 'identifier') {
+    qualifiers.push(tokens[i++].value)
+  }
+  qualifiers.pop()!
+
+  return tokens[i + 1]?.value === '(' ? parseFunction(qualifiers) : parseVariable(qualifiers, layout)
 }
 
 function parseStruct(): StructDeclaration {
@@ -290,7 +304,7 @@ function parseStruct(): StructDeclaration {
   const members: VariableDeclaration[] = []
   while (tokens[i] && tokens[i].value !== '}') {
     i++ // TODO: remove backtrack hack
-    members.push(parseVariable())
+    members.push(parseIndeterminate() as VariableDeclaration)
   }
   i++ // skip }
   i++ // skip ;
@@ -416,9 +430,7 @@ function parseStatements(): AST[] {
       else if (token.value === 'do') statement = parseDoWhile()
       else if (token.value === 'switch') statement = parseSwitch()
       else if (token.value === 'precision') statement = parsePrecision()
-      else if (isVariable(token.value) && tokens[i + 1]?.value === '(') statement = parseFunction()
-      else if (token.value === 'layout' || (isVariable(token.value) && tokens[i]?.value !== '('))
-        statement = parseVariable()
+      else if (isDeclaration(token.value)) statement = parseIndeterminate()
     }
 
     if (statement) {
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index da1a13a..ecad3ba 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -181,17 +181,20 @@ describe('parser', () => {
       expect(statement.type).toBeInstanceOf(Type)
       expect((statement.type as Type).name).toBe('void')
       expect((statement.type as Type).parameters).toBe(null)
+      expect(statement.qualifiers.length).toBe(0)
       expect(statement.args.length).toBe(0)
       expect(statement.body).toBe(null)
     }
 
     {
-      const statement = parse('void main(const bool enabled) {}')[0] as FunctionDeclaration
+      const statement = parse('highp vec4 main(const bool enabled) {}')[0] as FunctionDeclaration
       expect(statement).toBeInstanceOf(FunctionDeclaration)
       expect(statement.name).toBe('main')
       expect(statement.type).toBeInstanceOf(Type)
-      expect((statement.type as Type).name).toBe('void')
+      expect((statement.type as Type).name).toBe('vec4')
       expect((statement.type as Type).parameters).toBe(null)
+      expect(statement.qualifiers.length).toBe(1)
+      expect(statement.qualifiers[0]).toBe('highp')
       expect(statement.args[0]).toBeInstanceOf(VariableDeclaration)
       expect((statement.args[0] as VariableDeclaration).name).toBe('enabled')
       expect((statement.args[0] as VariableDeclaration).qualifiers.length).toBe(1)

From caf366c2952f1ed4786664bc94f115ad44837f24 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 18 Nov 2023 13:49:58 -0600
Subject: [PATCH 52/64] refactor: var declarators, kind

---
 src/ast.ts           | 14 ++++++++++----
 src/generator.ts     |  4 ++--
 src/parser.ts        | 10 ++++++++--
 tests/parser.test.ts | 38 ++++++++++++++++++++++----------------
 4 files changed, 42 insertions(+), 24 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 7bb9f5d..37495c4 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -24,13 +24,19 @@ export class Type extends Node {
   }
 }
 
+export class VariableDeclarator extends Node {
+  constructor(public name: string, public value: Node | null) {
+    super()
+  }
+}
+
 export class VariableDeclaration extends Node {
   constructor(
-    public name: string,
-    public type: Type | Identifier,
-    public value: Node | null,
-    public qualifiers: string[],
     public layout: Record<string, string | boolean> | null,
+    public qualifiers: string[],
+    public kind: 'var' | 'let' | 'const' | null,
+    public type: Type | Identifier,
+    public declarations: VariableDeclarator[],
   ) {
     super()
   }
diff --git a/src/generator.ts b/src/generator.ts
index f7fe144..9a82604 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -46,8 +46,8 @@ function format(node: AST | null): string {
     const cr = node.body.length ? '\n' : ''
     line = `{${cr}${node.body.map((node) => '  ' + punctuate(format(node))).join('')}}\n`
   } else if (node instanceof VariableDeclaration) {
-    const value = node.value ? ` = ${format(node.value)}` : ''
-    line = `${node.qualifiers.join(' ')} ${format(node.type)} ${node.name}${value};\n`.trimStart()
+    const body = node.declarations.map((d) => d.name + (d.value ? ` = ${format(d.value)}` : '')).join(', ')
+    line = `${node.qualifiers.join(' ')} ${format(node.type)} ${body};\n`.trimStart()
   } else if (node instanceof FunctionDeclaration) {
     const args = node.args.map((node) => format(node).replace(';\n', '')).join(', ')
     const body = node.body ? ` ${format(node.body)}` : ';\n'
diff --git a/src/parser.ts b/src/parser.ts
index 62bb251..86392e2 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -11,6 +11,7 @@ import {
   BlockStatement,
   FunctionDeclaration,
   VariableDeclaration,
+  VariableDeclarator,
   ContinueStatement,
   BreakStatement,
   DiscardStatement,
@@ -215,6 +216,7 @@ function parseVariable(
 ): VariableDeclaration {
   i-- // TODO: remove backtrack hack
 
+  const kind = null // TODO: WGSL
   const type = new Type(tokens[i++].value, null)
 
   const body = consumeUntil(';') // TODO: comma-separated lists
@@ -224,7 +226,9 @@ function parseVariable(
 
   const value = parseExpression(body)
 
-  return new VariableDeclaration(name, type, value, qualifiers, layout)
+  const declarations: VariableDeclarator[] = [new VariableDeclarator(name, value)]
+
+  return new VariableDeclaration(layout, qualifiers, kind, type, declarations)
 }
 
 function parseFunction(qualifiers: string[]): FunctionDeclaration {
@@ -252,7 +256,9 @@ function parseFunction(qualifiers: string[]): FunctionDeclaration {
 
     const value = parseExpression(line)
 
-    args.push(new VariableDeclaration(name, type, value, qualifiers, null))
+    const declarations: VariableDeclarator[] = [new VariableDeclarator(name, value)]
+
+    args.push(new VariableDeclaration(null, qualifiers, null, type, declarations))
   }
 
   let body = null
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index ecad3ba..7c897b4 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -126,13 +126,14 @@ describe('parser', () => {
     {
       const statement = parse('const vec4 foo = vec4(0, 0, 0, 0);')[0] as VariableDeclaration
       expect(statement).toBeInstanceOf(VariableDeclaration)
-      expect(statement.name).toBe('foo')
       expect(statement.type).toBeInstanceOf(Type)
       expect((statement.type as Type).name).toBe('vec4')
       expect((statement.type as Type).parameters).toBe(null)
       expect(statement.qualifiers.length).toBe(1)
       expect(statement.qualifiers[0]).toBe('const')
-      expect(statement.value).toBeInstanceOf(CallExpression)
+      expect(statement.declarations.length).toBe(1)
+      expect(statement.declarations[0].name).toBe('foo')
+      expect(statement.declarations[0].value).toBeInstanceOf(CallExpression)
     }
 
     {
@@ -140,14 +141,15 @@ describe('parser', () => {
         ' layout(location = 0, component = 1, column_major) flat in mat4 test;',
       )[0] as VariableDeclaration
       expect(statement).toBeInstanceOf(VariableDeclaration)
-      expect(statement.name).toBe('test')
       expect(statement.type).toBeInstanceOf(Type)
       expect((statement.type as Type).name).toBe('mat4')
       expect((statement.type as Type).parameters).toBe(null)
       expect(statement.qualifiers.length).toBe(2)
       expect(statement.qualifiers[0]).toBe('flat')
       expect(statement.qualifiers[1]).toBe('in')
-      expect(statement.value).toBe(null)
+      expect(statement.declarations.length).toBe(1)
+      expect(statement.declarations[0].name).toBe('test')
+      expect(statement.declarations[0].value).toBe(null)
       expect(statement.layout).not.toBe(null)
       expect(Object.keys(statement.layout as object).length).toBe(3)
       expect((statement.layout as any).location).toBe('0')
@@ -163,14 +165,15 @@ describe('parser', () => {
     expect(statement).toBeInstanceOf(StructDeclaration)
     expect(statement.name).toBe('foo')
     expect(statement.members.length).toBe(1)
-    expect(statement.members[0].name).toBe('bar')
     expect(statement.members[0].type).toBeInstanceOf(Type)
     expect((statement.members[0].type as Type).name).toBe('bool')
     expect((statement.members[0].type as Type).parameters).toBe(null)
     expect(statement.members[0].qualifiers.length).toBe(1)
     expect(statement.members[0].qualifiers[0]).toBe('const')
-    expect(statement.members[0].value).toBeInstanceOf(Literal)
-    expect((statement.members[0].value as Literal).value).toBe('true')
+    expect(statement.members[0].declarations.length).toBe(1)
+    expect(statement.members[0].declarations[0].name).toBe('bar')
+    expect(statement.members[0].declarations[0].value).toBeInstanceOf(Literal)
+    expect((statement.members[0].declarations[0].value as Literal).value).toBe('true')
   })
 
   it('parses function declarations', () => {
@@ -196,12 +199,14 @@ describe('parser', () => {
       expect(statement.qualifiers.length).toBe(1)
       expect(statement.qualifiers[0]).toBe('highp')
       expect(statement.args[0]).toBeInstanceOf(VariableDeclaration)
-      expect((statement.args[0] as VariableDeclaration).name).toBe('enabled')
-      expect((statement.args[0] as VariableDeclaration).qualifiers.length).toBe(1)
-      expect((statement.args[0] as VariableDeclaration).qualifiers[0]).toBe('const')
-      expect((statement.args[0] as VariableDeclaration).type).toBeInstanceOf(Type)
-      expect(((statement.args[0] as VariableDeclaration).type as Type).name).toBe('bool')
-      expect(((statement.args[0] as VariableDeclaration).type as Type).parameters).toBe(null)
+      expect(statement.args[0].qualifiers.length).toBe(1)
+      expect(statement.args[0].qualifiers[0]).toBe('const')
+      expect(statement.args[0].type).toBeInstanceOf(Type)
+      expect((statement.args[0].type as Type).name).toBe('bool')
+      expect((statement.args[0].type as Type).parameters).toBe(null)
+      expect(statement.args[0].declarations.length).toBe(1)
+      expect(statement.args[0].declarations[0].name).toBe('enabled')
+      expect(statement.args[0].declarations[0].value).toBe(null)
       expect(statement.body).toBeInstanceOf(BlockStatement)
       expect((statement.body as BlockStatement).body.length).toBe(0)
     }
@@ -266,12 +271,13 @@ describe('parser', () => {
     const statement = parse('for (int i = 0; i < 1; i++) {}')[0] as ForStatement
     expect(statement).toBeInstanceOf(ForStatement)
     expect(statement.init).toBeInstanceOf(VariableDeclaration)
-    expect((statement.init as VariableDeclaration).name).toBe('i')
     expect((statement.init as VariableDeclaration).type).toBeInstanceOf(Type)
     expect(((statement.init as VariableDeclaration).type as Type).name).toBe('int')
     expect(((statement.init as VariableDeclaration).type as Type).parameters).toBe(null)
-    expect((statement.init as VariableDeclaration).value).toBeInstanceOf(Literal)
-    expect(((statement.init as VariableDeclaration).value as Literal).value).toBe('0')
+    expect((statement.init as VariableDeclaration).declarations.length).toBe(1)
+    expect((statement.init as VariableDeclaration).declarations[0].name).toBe('i')
+    expect((statement.init as VariableDeclaration).declarations[0].value).toBeInstanceOf(Literal)
+    expect(((statement.init as VariableDeclaration).declarations[0].value as Literal).value).toBe('0')
     expect((statement.init as VariableDeclaration).qualifiers.length).toBe(0)
     expect(statement.test).toBeInstanceOf(BinaryExpression)
     expect((statement.test as BinaryExpression).operator).toBe('<')

From dbef3126ad4339a861d395ee6c3a3d9ef162d054 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 18 Nov 2023 15:02:28 -0600
Subject: [PATCH 53/64] refactor: comma-separated lists

---
 src/parser.ts        | 20 +++++++++++++-------
 tests/parser.test.ts | 22 +++++++++++++++++++++-
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 86392e2..5b57c1c 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -31,7 +31,6 @@ import { type Token, tokenize } from './tokenizer'
 const UNARY_OPERATORS = ['+', '-', '~', '!', '++', '--']
 
 const BINARY_OPERATORS = [
-  ',',
   '>>=',
   '<<=',
   '|=',
@@ -219,14 +218,21 @@ function parseVariable(
   const kind = null // TODO: WGSL
   const type = new Type(tokens[i++].value, null)
 
-  const body = consumeUntil(';') // TODO: comma-separated lists
-  const name = body.shift()!.value
-  body.shift() // skip =
-  body.pop() // skip ;
+  const declarations: VariableDeclarator[] = []
+
+  const body = consumeUntil(';')
+  let j = 0
+
+  while (j < body.length) {
+    const name = body[j++].value
+    j++ // skip =
 
-  const value = parseExpression(body)
+    const right = readUntil(',', body, j)
+    const value = parseExpression(readUntil(',', body, j))
+    j += right.length
 
-  const declarations: VariableDeclarator[] = [new VariableDeclarator(name, value)]
+    declarations.push(new VariableDeclarator(name, value))
+  }
 
   return new VariableDeclaration(layout, qualifiers, kind, type, declarations)
 }
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index 7c897b4..436a264 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -157,7 +157,27 @@ describe('parser', () => {
       expect((statement.layout as any).column_major).toBe(true)
     }
 
-    // TODO: comma-separated list
+    {
+      const statement = parse('float foo = 0.0, bar = foo + 1.0, baz;')[0] as VariableDeclaration
+      expect(statement).toBeInstanceOf(VariableDeclaration)
+      expect(statement.type).toBeInstanceOf(Type)
+      expect((statement.type as Type).name).toBe('float')
+      expect((statement.type as Type).parameters).toBe(null)
+      expect(statement.qualifiers.length).toBe(0)
+      expect(statement.declarations.length).toBe(3)
+      expect(statement.declarations[0].name).toBe('foo')
+      expect(statement.declarations[0].value).toBeInstanceOf(Literal)
+      expect((statement.declarations[0].value as Literal).value).toBe('0.0')
+      expect(statement.declarations[1].name).toBe('bar')
+      expect(statement.declarations[1].value).toBeInstanceOf(BinaryExpression)
+      expect((statement.declarations[1].value as BinaryExpression).operator).toBe('+')
+      expect((statement.declarations[1].value as BinaryExpression).left).toBeInstanceOf(Identifier)
+      expect(((statement.declarations[1].value as BinaryExpression).left as Identifier).value).toBe('foo')
+      expect((statement.declarations[1].value as BinaryExpression).right).toBeInstanceOf(Literal)
+      expect(((statement.declarations[1].value as BinaryExpression).right as Literal).value).toBe('1.0')
+      expect(statement.declarations[2].name).toBe('baz')
+      expect(statement.declarations[2].value).toBe(null)
+    }
   })
 
   it('parses struct declarations', () => {

From c661968759eb74e772e5b710c251b48b5b22ea47 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 18 Nov 2023 15:22:34 -0600
Subject: [PATCH 54/64] chore: cleanup

---
 src/generator.ts | 19 ++++++++++--
 src/parser.ts    | 76 ++++++++++++++++++++++--------------------------
 2 files changed, 51 insertions(+), 44 deletions(-)

diff --git a/src/generator.ts b/src/generator.ts
index 9a82604..b1f6564 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -46,12 +46,25 @@ function format(node: AST | null): string {
     const cr = node.body.length ? '\n' : ''
     line = `{${cr}${node.body.map((node) => '  ' + punctuate(format(node))).join('')}}\n`
   } else if (node instanceof VariableDeclaration) {
+    let layout = ''
+    if (node.layout) {
+      const args: string[] = []
+      for (const key in node.layout) {
+        const value = node.layout[key]
+        if (typeof value === 'string') args.push(`${key} = ${value}`)
+        else args.push(key)
+      }
+      layout = `layout(${args.join(', ')}) `
+    }
+
+    const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : ''
     const body = node.declarations.map((d) => d.name + (d.value ? ` = ${format(d.value)}` : '')).join(', ')
-    line = `${node.qualifiers.join(' ')} ${format(node.type)} ${body};\n`.trimStart()
+    line = `${layout}${qualifiers}${format(node.type)} ${body};\n`.trimStart()
   } else if (node instanceof FunctionDeclaration) {
+    const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : ''
     const args = node.args.map((node) => format(node).replace(';\n', '')).join(', ')
     const body = node.body ? ` ${format(node.body)}` : ';\n'
-    line = `${format(node.type)} ${node.name}(${args})${body}`
+    line = `${qualifiers}${format(node.type)} ${node.name}(${args})${body}`
   } else if (node instanceof CallExpression) {
     line = `${format(node.callee)}(${node.args.map(format).join(', ')})`
   } else if (node instanceof MemberExpression) {
@@ -113,5 +126,5 @@ export function generate(ast: AST[], options: GenerateOptions): string {
     code += punctuate(format(ast[i]))
   }
 
-  return code
+  return code.trim()
 }
diff --git a/src/parser.ts b/src/parser.ts
index 5b57c1c..6955355 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -477,57 +477,51 @@ export function parse(code: string): AST[] {
 }
 
 const glsl = /* glsl */ `#version 300 es
-  precision highp float;
+precision highp float;
 
-  layout(location = 0, component = 1) flat in mat4 test;
+layout(location = 0, component = 1) flat in mat4 test;
 
-  struct foo {
-    bool isStruct;
-    vec4 color;
-  };
+float foo = 0.0, bar = foo + 1.0, baz;
 
-  if (true) {
-    discard;
-  } else if (false) {
-    //
-  } else {
-    //
-  }
+struct foo {
+  bool isStruct;
+  vec4 color;
+};
 
-  for (int i = 0; i < 10; i++) {
-    //
-  }
+if (true) {
+  discard;
+} else if (false) {} else {}
 
-  while(true) {
-    //
-  }
+for (int i = 0; i < 10; i++) {}
 
-  do {
-    //
-  } while (true);
-
-  switch(true) {
-    case 0:
-      break;
-    case 1:
-      break;
-    default:
-      //
-  }
+while (true) {}
 
-  void method(const bool foo);
+do {} while (true);
 
-  void main() {
-    gl_FragColor = vec4(1, 0, 0, 1); // red
-  }
+switch(true) {
+  case 0:
+    break;
+  case 1:
+    break;
+  default:
+    break;
+}
 
-  method(true);
+highp float method(const bool foo);
 
-  foo.bar();
-`
+void main() {
+  gl_FragColor = vec4(1, 0, 0, 1);
+}
+
+method(true);
+
+foo.bar();
+`.trim()
 
-console.log(glsl)
 const ast = parse(glsl)
-console.log(...ast)
+const output = generate(ast, { target: 'GLSL' })
 
-console.log(generate(ast, { target: 'GLSL' }))
+console.log(glsl)
+console.log(...ast)
+console.log(output)
+console.log(glsl.replace(/\n+/g, '\n') === output)

From 86e2dbf35ebf46dc9a85b870684d3688917957dc Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sat, 18 Nov 2023 18:39:44 -0600
Subject: [PATCH 55/64] refactor: parse var array type

---
 src/ast.ts           |  2 +-
 src/generator.ts     | 18 +++++++++++++++++-
 src/parser.ts        | 27 +++++++++++++++++++++++----
 tests/parser.test.ts |  8 ++++++--
 4 files changed, 47 insertions(+), 8 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 37495c4..4b36fce 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -67,7 +67,7 @@ export class MemberExpression extends Node {
 }
 
 export class ArrayExpression extends Node {
-  constructor(public members: Node[]) {
+  constructor(public members: Node[], public length: Node | null) {
     super()
   }
 }
diff --git a/src/generator.ts b/src/generator.ts
index b1f6564..7b4bb38 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -58,7 +58,23 @@ function format(node: AST | null): string {
     }
 
     const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : ''
-    const body = node.declarations.map((d) => d.name + (d.value ? ` = ${format(d.value)}` : '')).join(', ')
+
+    let body = ''
+    if (node.declarations.length) {
+      const members: string[] = []
+      for (const declaration of node.declarations) {
+        let value = ''
+        if (declaration.value instanceof ArrayExpression && !declaration.value.members.length) {
+          value = `[${format(declaration.value.length)}]`
+        } else if (declaration.value) {
+          value = ` = ${format(declaration.value)}`
+        }
+
+        members.push(`${declaration.name}${value}`)
+      }
+      body = members.join(', ')
+    }
+
     line = `${layout}${qualifiers}${format(node.type)} ${body};\n`.trimStart()
   } else if (node instanceof FunctionDeclaration) {
     const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : ''
diff --git a/src/parser.ts b/src/parser.ts
index 6955355..b7c6efe 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -24,6 +24,7 @@ import {
   SwitchCase,
   StructDeclaration,
   PrecisionStatement,
+  ArrayExpression,
 } from './ast'
 import { generate } from './generator'
 import { type Token, tokenize } from './tokenizer'
@@ -183,7 +184,7 @@ function parseExpression(body: Token[]): AST | null {
       while (i < body.length) {
         const line = readUntil(',', body, i)
         i += line.length
-        if (line.at(-1)?.value === ',') line.pop() // skip ,
+        if (line[line.length - 1]?.value === ',') line.pop() // skip ,
 
         const arg = parseExpression(line)
         if (arg) args.push(arg)
@@ -225,10 +226,18 @@ function parseVariable(
 
   while (j < body.length) {
     const name = body[j++].value
+
+    let prefix: AST | null = null
+    if (body[j].value === '[') {
+      j++ // skip [
+      prefix = new ArrayExpression([], parseExpression([body[j++]]))
+      j++ // skip ]
+    }
+
     j++ // skip =
 
     const right = readUntil(',', body, j)
-    const value = parseExpression(readUntil(',', body, j))
+    const value = parseExpression(readUntil(',', body, j)) ?? prefix
     j += right.length
 
     declarations.push(new VariableDeclarator(name, value))
@@ -258,9 +267,17 @@ function parseFunction(qualifiers: string[]): FunctionDeclaration {
     j += line.length
 
     const name = line.shift()!.value
-    if (line.at(-1)?.value === ',') line.pop() // skip ,
 
-    const value = parseExpression(line)
+    let prefix: AST | null = null
+    if (line[0]?.value === '[') {
+      line.shift() // skip [
+      prefix = new ArrayExpression([], parseExpression([line.shift()!]))
+      line.shift() // skip ]
+    }
+
+    if (line[line.length - 1]?.value === ',') line.pop() // skip ,
+
+    const value = parseExpression(line) ?? prefix
 
     const declarations: VariableDeclarator[] = [new VariableDeclarator(name, value)]
 
@@ -516,6 +533,8 @@ void main() {
 method(true);
 
 foo.bar();
+
+uniform float test[3];
 `.trim()
 
 const ast = parse(glsl)
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index 436a264..de18286 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -24,6 +24,7 @@ import {
   SwitchStatement,
   SwitchCase,
   PrecisionStatement,
+  ArrayExpression,
 } from 'shaderkit'
 
 describe('parser', () => {
@@ -158,7 +159,7 @@ describe('parser', () => {
     }
 
     {
-      const statement = parse('float foo = 0.0, bar = foo + 1.0, baz;')[0] as VariableDeclaration
+      const statement = parse('float foo = 0.0, bar = foo + 1.0, baz[3];')[0] as VariableDeclaration
       expect(statement).toBeInstanceOf(VariableDeclaration)
       expect(statement.type).toBeInstanceOf(Type)
       expect((statement.type as Type).name).toBe('float')
@@ -176,7 +177,10 @@ describe('parser', () => {
       expect((statement.declarations[1].value as BinaryExpression).right).toBeInstanceOf(Literal)
       expect(((statement.declarations[1].value as BinaryExpression).right as Literal).value).toBe('1.0')
       expect(statement.declarations[2].name).toBe('baz')
-      expect(statement.declarations[2].value).toBe(null)
+      expect(statement.declarations[2].value).toBeInstanceOf(ArrayExpression)
+      expect((statement.declarations[2].value as ArrayExpression).members.length).toBe(0)
+      expect((statement.declarations[2].value as ArrayExpression).length).toBeInstanceOf(Literal)
+      expect(((statement.declarations[2].value as ArrayExpression).length as Literal).value).toBe('3')
     }
   })
 

From 734686cf311e76687dad0eeaf6f9e04d2c55a601 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sun, 19 Nov 2023 03:29:00 -0600
Subject: [PATCH 56/64] refactor: array expressions

---
 src/ast.ts           |  2 +-
 src/generator.ts     | 18 ++++++++++++++----
 src/parser.ts        | 33 ++++++++++++++++++++++++++++-----
 tests/parser.test.ts | 24 ++++++++++++++++++++++--
 4 files changed, 65 insertions(+), 12 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index 4b36fce..bc3511d 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -67,7 +67,7 @@ export class MemberExpression extends Node {
 }
 
 export class ArrayExpression extends Node {
-  constructor(public members: Node[], public length: Node | null) {
+  constructor(public type: Type, public members: Node[]) {
     super()
   }
 }
diff --git a/src/generator.ts b/src/generator.ts
index 7b4bb38..22b9b50 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -59,13 +59,22 @@ function format(node: AST | null): string {
 
     const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : ''
 
+    let type = format(node.type)
+
     let body = ''
     if (node.declarations.length) {
       const members: string[] = []
       for (const declaration of node.declarations) {
         let value = ''
-        if (declaration.value instanceof ArrayExpression && !declaration.value.members.length) {
-          value = `[${format(declaration.value.length)}]`
+
+        if (declaration.value instanceof ArrayExpression) {
+          const t = declaration.value.type
+          const params = t.parameters ? t.parameters?.map(format).join(', ') : ''
+          value = `[${params}]`
+
+          if (declaration.value.members.length) {
+            value += ` = ${type}[${params}](${declaration.value.members.map(format).join(', ')})`
+          }
         } else if (declaration.value) {
           value = ` = ${format(declaration.value)}`
         }
@@ -75,7 +84,7 @@ function format(node: AST | null): string {
       body = members.join(', ')
     }
 
-    line = `${layout}${qualifiers}${format(node.type)} ${body};\n`.trimStart()
+    line = `${layout}${qualifiers}${type} ${body};\n`.trimStart()
   } else if (node instanceof FunctionDeclaration) {
     const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : ''
     const args = node.args.map((node) => format(node).replace(';\n', '')).join(', ')
@@ -86,7 +95,8 @@ function format(node: AST | null): string {
   } else if (node instanceof MemberExpression) {
     line = `${format(node.object)}.${format(node.property)}`
   } else if (node instanceof ArrayExpression) {
-    // TODO
+    const params = node.type.parameters ? node.type.parameters?.map(format).join(', ') : ''
+    line = `${node.type.name}[${params}](${node.members.map(format).join(', ')})`
   } else if (node instanceof IfStatement) {
     const consequent = format(node.consequent).replace(EOL_REGEX, '')
     const alternate = node.alternate ? ` else ${format(node.alternate).replace(EOL_REGEX, '')}` : ''
diff --git a/src/parser.ts b/src/parser.ts
index b7c6efe..b26008f 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -191,7 +191,7 @@ function parseExpression(body: Token[]): AST | null {
       }
 
       return new CallExpression(callee, args)
-    } else if (second.value === '.' || second.value === '[') {
+    } else if (second.value === '.') {
       const object = new Identifier(first.value)
       const property = parseExpression([body[2]])!
       const left = new MemberExpression(object, property)
@@ -204,6 +204,29 @@ function parseExpression(body: Token[]): AST | null {
       }
 
       return left
+    } else if (second.value === '[') {
+      let i = 2
+
+      const type = new Type(first.value, [])
+
+      if (body[i].value !== ']') type.parameters!.push(parseExpression([body[i++]]) as any)
+      i++ // skip ]
+
+      const scope = readUntil(')', body, i).slice(1, -1)
+
+      const members: AST[] = []
+
+      let j = 0
+      while (j < scope.length) {
+        const next = readUntil(',', scope, j)
+        j += next.length
+
+        if (next[next.length - 1].value === ',') next.pop()
+
+        members.push(parseExpression(next)!)
+      }
+
+      return new ArrayExpression(type, members)
     }
   }
 
@@ -230,7 +253,7 @@ function parseVariable(
     let prefix: AST | null = null
     if (body[j].value === '[') {
       j++ // skip [
-      prefix = new ArrayExpression([], parseExpression([body[j++]]))
+      prefix = new ArrayExpression(new Type(type.name, [parseExpression([body[j++]]) as any]), [])
       j++ // skip ]
     }
 
@@ -271,7 +294,7 @@ function parseFunction(qualifiers: string[]): FunctionDeclaration {
     let prefix: AST | null = null
     if (line[0]?.value === '[') {
       line.shift() // skip [
-      prefix = new ArrayExpression([], parseExpression([line.shift()!]))
+      prefix = new ArrayExpression(new Type(type.name, [parseExpression([line.shift()!]) as any]), [])
       line.shift() // skip ]
     }
 
@@ -459,7 +482,7 @@ function parseStatements(): AST[] {
       else if (token.value === 'do') statement = parseDoWhile()
       else if (token.value === 'switch') statement = parseSwitch()
       else if (token.value === 'precision') statement = parsePrecision()
-      else if (isDeclaration(token.value)) statement = parseIndeterminate()
+      else if (isDeclaration(token.value) && tokens[i].value !== '[') statement = parseIndeterminate()
     }
 
     if (statement) {
@@ -534,7 +557,7 @@ method(true);
 
 foo.bar();
 
-uniform float test[3];
+const float array[3] = float[3](2.5, 7.0, 1.5);
 `.trim()
 
 const ast = parse(glsl)
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index de18286..d2ba311 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -179,8 +179,11 @@ describe('parser', () => {
       expect(statement.declarations[2].name).toBe('baz')
       expect(statement.declarations[2].value).toBeInstanceOf(ArrayExpression)
       expect((statement.declarations[2].value as ArrayExpression).members.length).toBe(0)
-      expect((statement.declarations[2].value as ArrayExpression).length).toBeInstanceOf(Literal)
-      expect(((statement.declarations[2].value as ArrayExpression).length as Literal).value).toBe('3')
+      expect((statement.declarations[2].value as ArrayExpression).type).toBeInstanceOf(Type)
+      expect((statement.declarations[2].value as ArrayExpression).type.name).toBe('float')
+      expect((statement.declarations[2].value as ArrayExpression).type.parameters!.length).toBe(1)
+      expect((statement.declarations[2].value as ArrayExpression).type.parameters![0]).toBeInstanceOf(Literal)
+      expect(((statement.declarations[2].value as ArrayExpression).type.parameters![0] as Literal).value).toBe('3')
     }
   })
 
@@ -351,4 +354,21 @@ describe('parser', () => {
     expect(statement.type.name).toBe('float')
     expect(statement.type.parameters).toBe(null)
   })
+
+  it('parses array expressions', () => {
+    const statement = parse('float[3](2.5, 7.0, 1.5);')[0] as ArrayExpression
+    expect(statement).toBeInstanceOf(ArrayExpression)
+    expect(statement.type).toBeInstanceOf(Type)
+    expect(statement.type.name).toBe('float')
+    expect(statement.type.parameters!.length).toBe(1)
+    expect(statement.type.parameters![0]).toBeInstanceOf(Literal)
+    expect((statement.type.parameters![0] as Literal).value).toBe('3')
+    expect(statement.members.length).toBe(3)
+    expect(statement.members[0]).toBeInstanceOf(Literal)
+    expect((statement.members[0] as Literal).value).toBe('2.5')
+    expect(statement.members[1]).toBeInstanceOf(Literal)
+    expect((statement.members[1] as Literal).value).toBe('7.0')
+    expect(statement.members[2]).toBeInstanceOf(Literal)
+    expect((statement.members[2] as Literal).value).toBe('1.5')
+  })
 })

From 3a3c58167bd3be863aaefd4ea6385b65755f1b1c Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sun, 19 Nov 2023 07:25:09 -0600
Subject: [PATCH 57/64] refactor: preprocessor statements

---
 src/ast.ts           |  7 ++++++
 src/generator.ts     | 14 +++++++++++
 src/parser.ts        | 53 ++++++++++++++++++++++++++++++++++++--
 tests/parser.test.ts | 60 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 132 insertions(+), 2 deletions(-)

diff --git a/src/ast.ts b/src/ast.ts
index bc3511d..14ef40b 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -18,6 +18,12 @@ export class BlockStatement extends Node {
   }
 }
 
+export class PreprocessorStatement extends Node {
+  constructor(public name: string, public value: Node[] | null) {
+    super()
+  }
+}
+
 export class Type extends Node {
   constructor(public name: string, public parameters: (Type | Literal | Identifier)[] | null) {
     super()
@@ -173,3 +179,4 @@ export type AST =
   | ContinueStatement
   | BreakStatement
   | DiscardStatement
+  | PreprocessorStatement
diff --git a/src/generator.ts b/src/generator.ts
index 22b9b50..7883796 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -24,6 +24,7 @@ import {
   ContinueStatement,
   BreakStatement,
   DiscardStatement,
+  PreprocessorStatement,
 } from './ast'
 
 const EOL_REGEX = /\n$/
@@ -133,6 +134,19 @@ function format(node: AST | null): string {
     line = 'break;\n'
   } else if (node instanceof DiscardStatement) {
     line = 'discard;\n'
+  } else if (node instanceof PreprocessorStatement) {
+    let value = ''
+    if (node.value) {
+      if (node.name === 'include') {
+        value = ` <${format(node.value[0])}>`
+      } else if (node.name === 'extension') {
+        value = ` ${node.value.map(format).join(': ')}`
+      } else {
+        value = ` ${node.value.map(format).join(' ')}`
+      }
+    }
+
+    line = `#${node.name}${value}\n`
   }
 
   return line
diff --git a/src/parser.ts b/src/parser.ts
index b26008f..f59c8c0 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -25,6 +25,7 @@ import {
   StructDeclaration,
   PrecisionStatement,
   ArrayExpression,
+  PreprocessorStatement,
 } from './ast'
 import { generate } from './generator'
 import { type Token, tokenize } from './tokenizer'
@@ -455,6 +456,34 @@ function parsePrecision(): PrecisionStatement {
   return new PrecisionStatement(precision as any, type)
 }
 
+function parsePreprocessor(): PreprocessorStatement {
+  const name = tokens[i++].value
+
+  const body = consumeUntil('\\').slice(0, -1)
+  let value: AST[] | null = null
+
+  if (name !== 'else' && name !== 'endif') {
+    value = []
+
+    if (name === 'define') {
+      const left = parseExpression([body.shift()!])!
+      const right = parseExpression(body)!
+      value.push(left, right)
+    } else if (name === 'extension') {
+      const left = parseExpression([body.shift()!])!
+      body.shift() // skip :
+      const right = parseExpression(body)!
+      value.push(left, right)
+    } else if (name === 'include') {
+      value.push(parseExpression(body.slice(1, -1))!)
+    } else {
+      value.push(parseExpression(body)!)
+    }
+  }
+
+  return new PreprocessorStatement(name, value)
+}
+
 function parseStatements(): AST[] {
   const body: AST[] = []
   let scopeIndex = 0
@@ -467,7 +496,9 @@ function parseStatements(): AST[] {
 
     let statement: AST | null = null
 
-    if (token.type === 'keyword') {
+    if (token.value === '#') {
+      statement = parsePreprocessor()
+    } else if (token.type === 'keyword') {
       if (token.value === 'case' || token.value === 'default') {
         i--
         break
@@ -504,12 +535,19 @@ function parseBlock(): BlockStatement {
   return new BlockStatement(body)
 }
 
+const DIRECTIVE_REGEX = /(^\s*#[^\\]*?)(\n|\/[\/\*])/gm
+
 /**
  * Parses a string of GLSL or WGSL code into an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
  */
 export function parse(code: string): AST[] {
-  // TODO: preserve
+  // Remove (implicit) version header
   code = code.replace('#version 300 es', '')
+
+  // Escape newlines after directives, skip comments
+  code = code.replace(DIRECTIVE_REGEX, '$1\\$2')
+
+  // TODO: preserve
   tokens = tokenize(code).filter((token) => token.type !== 'whitespace' && token.type !== 'comment')
   i = 0
 
@@ -553,6 +591,17 @@ void main() {
   gl_FragColor = vec4(1, 0, 0, 1);
 }
 
+#line 0
+#define TEST 1
+#extension all: disable
+#error test
+#pragma optimize(on)
+#include <chunk>
+
+#ifdef TEST
+test;
+#endif
+
 method(true);
 
 foo.bar();
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index d2ba311..674eb95 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -25,6 +25,7 @@ import {
   SwitchCase,
   PrecisionStatement,
   ArrayExpression,
+  PreprocessorStatement,
 } from 'shaderkit'
 
 describe('parser', () => {
@@ -371,4 +372,63 @@ describe('parser', () => {
     expect(statement.members[2]).toBeInstanceOf(Literal)
     expect((statement.members[2] as Literal).value).toBe('1.5')
   })
+
+  it('parses preprocessor statements', () => {
+    {
+      const statement = parse('#define TEST 1\n')[0] as PreprocessorStatement
+      expect(statement).toBeInstanceOf(PreprocessorStatement)
+      expect(statement.name).toBe('define')
+      console.log(statement.value)
+      expect(statement.value!.length).toBe(2)
+      expect(statement.value![0]).toBeInstanceOf(Identifier)
+      expect((statement.value![0] as Identifier).value).toBe('TEST')
+      expect(statement.value![1]).toBeInstanceOf(Literal)
+      expect((statement.value![1] as Literal).value).toBe('1')
+    }
+
+    {
+      const statement = parse('#extension all: disable\n')[0] as PreprocessorStatement
+      expect(statement).toBeInstanceOf(PreprocessorStatement)
+      expect(statement.name).toBe('extension')
+      expect(statement.value!.length).toBe(2)
+    }
+
+    {
+      const statement = parse('#pragma optimize(on)\n')[0] as PreprocessorStatement
+      expect(statement).toBeInstanceOf(PreprocessorStatement)
+      expect(statement.name).toBe('pragma')
+      expect(statement.value!.length).toBe(1)
+      expect(statement.value![0]).toBeInstanceOf(CallExpression)
+      expect((statement.value![0] as CallExpression).callee).toBeInstanceOf(Identifier)
+      expect(((statement.value![0] as CallExpression).callee as Identifier).value).toBe('optimize')
+      expect((statement.value![0] as CallExpression).args.length).toBe(1)
+      expect((statement.value![0] as CallExpression).args[0]).toBeInstanceOf(Identifier)
+      expect(((statement.value![0] as CallExpression).args[0] as Identifier).value).toBe('on')
+    }
+
+    {
+      const statement = parse('#include <chunk>\n')[0] as PreprocessorStatement
+      expect(statement).toBeInstanceOf(PreprocessorStatement)
+      expect(statement.name).toBe('include')
+      expect(statement.value!.length).toBe(1)
+      expect(statement.value![0]).toBeInstanceOf(Identifier)
+      expect((statement.value![0] as Identifier).value).toBe('chunk')
+    }
+
+    {
+      const statement = parse('#ifdef TEST\n')[0] as PreprocessorStatement
+      expect(statement).toBeInstanceOf(PreprocessorStatement)
+      expect(statement.name).toBe('ifdef')
+      expect(statement.value!.length).toBe(1)
+      expect(statement.value![0]).toBeInstanceOf(Identifier)
+      expect((statement.value![0] as Identifier).value).toBe('TEST')
+    }
+
+    {
+      const statement = parse('#endif\n')[0] as PreprocessorStatement
+      expect(statement).toBeInstanceOf(PreprocessorStatement)
+      expect(statement.name).toBe('endif')
+      expect(statement.value).toBe(null)
+    }
+  })
 })

From c1054ad0cc5995358e0b4c9f153418051f5f22bb Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sun, 19 Nov 2023 13:27:16 -0600
Subject: [PATCH 58/64] refactor: callexpr + memberexpr

---
 src/parser.ts        | 24 ++++++++++++++++++------
 tests/parser.test.ts | 12 +++++++++++-
 2 files changed, 29 insertions(+), 7 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index f59c8c0..2fdf5c8 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -179,19 +179,29 @@ function parseExpression(body: Token[]): AST | null {
       const callee = new Identifier(first.value)
       const args: AST[] = []
 
-      body = body.slice(2, -1) // skip ()
-      let i = 0
+      const scope = readUntil(')', body, 1).slice(1, -1)
 
-      while (i < body.length) {
-        const line = readUntil(',', body, i)
-        i += line.length
+      let j = 0
+      while (j < scope.length) {
+        const line = readUntil(',', scope, j)
+        j += line.length
         if (line[line.length - 1]?.value === ',') line.pop() // skip ,
 
         const arg = parseExpression(line)
         if (arg) args.push(arg)
       }
 
-      return new CallExpression(callee, args)
+      const expression = new CallExpression(callee, args)
+
+      // e.g. texture().rgb
+      let i = 3 + j
+      if (body[i]?.value === '.') {
+        const right = parseExpression([first, ...body.slice(i)])! as MemberExpression
+        right.object = expression
+        return right
+      }
+
+      return expression
     } else if (second.value === '.') {
       const object = new Identifier(first.value)
       const property = parseExpression([body[2]])!
@@ -607,6 +617,8 @@ method(true);
 foo.bar();
 
 const float array[3] = float[3](2.5, 7.0, 1.5);
+
+texture().rgb;
 `.trim()
 
 const ast = parse(glsl)
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index 674eb95..2e4e20c 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -122,6 +122,17 @@ describe('parser', () => {
       expect(((expression.callee as MemberExpression).property as Identifier).value).toBe('length')
       expect(expression.args.length).toBe(0)
     }
+
+    {
+      const expression = parse('texture().rgb')[0] as MemberExpression
+      expect(expression).toBeInstanceOf(MemberExpression)
+      expect(expression.object).toBeInstanceOf(CallExpression)
+      expect((expression.object as CallExpression).callee).toBeInstanceOf(Identifier)
+      expect(((expression.object as CallExpression).callee as Identifier).value).toBe('texture')
+      expect((expression.object as CallExpression).args.length).toBe(0)
+      expect(expression.property).toBeInstanceOf(Identifier)
+      expect((expression.property as Identifier).value).toBe('rgb')
+    }
   })
 
   it('parses variable declarations', () => {
@@ -378,7 +389,6 @@ describe('parser', () => {
       const statement = parse('#define TEST 1\n')[0] as PreprocessorStatement
       expect(statement).toBeInstanceOf(PreprocessorStatement)
       expect(statement.name).toBe('define')
-      console.log(statement.value)
       expect(statement.value!.length).toBe(2)
       expect(statement.value![0]).toBeInstanceOf(Identifier)
       expect((statement.value![0] as Identifier).value).toBe('TEST')

From 95a220d8742233e790f53be44cb41d5f27be77ec Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Sun, 19 Nov 2023 16:19:11 -0600
Subject: [PATCH 59/64] refactor: parse user types

---
 src/parser.ts        |  8 ++++----
 tests/parser.test.ts | 13 +++++++++++++
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 2fdf5c8..e8d5cc1 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -68,8 +68,8 @@ const BINARY_OPERATORS = [
 
 // TODO: this is GLSL-only, separate language constants
 const TYPE_REGEX = /void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?/
-const QUALIFIER_REGEX = /in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp/
-const VARIABLE_REGEX = new RegExp(`${TYPE_REGEX.source}|${QUALIFIER_REGEX.source}|const|uniform`)
+const QUALIFIER_REGEX = /const|uniform|in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp/
+const VARIABLE_REGEX = new RegExp(`${TYPE_REGEX.source}|${QUALIFIER_REGEX.source}`)
 
 const isDeclaration = RegExp.prototype.test.bind(VARIABLE_REGEX)
 
@@ -353,10 +353,10 @@ function parseIndeterminate(): VariableDeclaration | FunctionDeclaration {
   }
 
   const qualifiers: string[] = []
-  while (tokens[i] && tokens[i].type !== 'identifier') {
+  while (tokens[i] && QUALIFIER_REGEX.test(tokens[i].value)) {
     qualifiers.push(tokens[i++].value)
   }
-  qualifiers.pop()!
+  i++
 
   return tokens[i + 1]?.value === '(' ? parseFunction(qualifiers) : parseVariable(qualifiers, layout)
 }
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index 2e4e20c..45755df 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -136,6 +136,19 @@ describe('parser', () => {
   })
 
   it('parses variable declarations', () => {
+    {
+      const statement = parse('uniform Type foo;')[0] as VariableDeclaration
+      expect(statement).toBeInstanceOf(VariableDeclaration)
+      expect(statement.type).toBeInstanceOf(Type)
+      expect((statement.type as Type).name).toBe('Type')
+      expect((statement.type as Type).parameters).toBe(null)
+      expect(statement.qualifiers.length).toBe(1)
+      expect(statement.qualifiers[0]).toBe('uniform')
+      expect(statement.declarations.length).toBe(1)
+      expect(statement.declarations[0].name).toBe('foo')
+      expect(statement.declarations[0].value).toBe(null)
+    }
+
     {
       const statement = parse('const vec4 foo = vec4(0, 0, 0, 0);')[0] as VariableDeclaration
       expect(statement).toBeInstanceOf(VariableDeclaration)

From 1fbea18d1efcaf44803314f17efb80f25375e031 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Tue, 21 Nov 2023 05:26:22 -0600
Subject: [PATCH 60/64] refactor: harden qualifier match

---
 src/generator.ts     | 2 +-
 src/parser.ts        | 4 ++--
 tests/parser.test.ts | 5 ++++-
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/generator.ts b/src/generator.ts
index 7883796..394a8cf 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -111,7 +111,7 @@ function format(node: AST | null): string {
     line = `do ${format(node.body).replace(EOL_REGEX, '')} while (${format(node.test)});\n`
   } else if (node instanceof SwitchStatement) {
     const cr = node.cases.length ? '\n' : ''
-    line = `switch(${format(node.discriminant)}) {${cr}${node.cases.map(format).join('')}}\n`
+    line = `switch (${format(node.discriminant)}) {${cr}${node.cases.map(format).join('')}}\n`
   } else if (node instanceof SwitchCase) {
     const header = node.test ? `case ${format(node.test)}:` : 'default:'
     line = `  ${header}\n${node.consequent.map((node) => `    ${punctuate(format(node))}`).join('')}`
diff --git a/src/parser.ts b/src/parser.ts
index e8d5cc1..15919a0 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -67,8 +67,8 @@ const BINARY_OPERATORS = [
 ]
 
 // TODO: this is GLSL-only, separate language constants
-const TYPE_REGEX = /void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?/
-const QUALIFIER_REGEX = /const|uniform|in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp/
+const TYPE_REGEX = /^(void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?)$/
+const QUALIFIER_REGEX = /^(const|uniform|in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp)$/
 const VARIABLE_REGEX = new RegExp(`${TYPE_REGEX.source}|${QUALIFIER_REGEX.source}`)
 
 const isDeclaration = RegExp.prototype.test.bind(VARIABLE_REGEX)
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index 45755df..ffa7082 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -242,7 +242,7 @@ describe('parser', () => {
     }
 
     {
-      const statement = parse('highp vec4 main(const bool enabled) {}')[0] as FunctionDeclaration
+      const statement = parse('highp vec4 main(const bool enabled, bool disabled) {}')[0] as FunctionDeclaration
       expect(statement).toBeInstanceOf(FunctionDeclaration)
       expect(statement.name).toBe('main')
       expect(statement.type).toBeInstanceOf(Type)
@@ -259,6 +259,9 @@ describe('parser', () => {
       expect(statement.args[0].declarations.length).toBe(1)
       expect(statement.args[0].declarations[0].name).toBe('enabled')
       expect(statement.args[0].declarations[0].value).toBe(null)
+      expect(statement.args[1].declarations.length).toBe(1)
+      expect(statement.args[1].declarations[0].name).toBe('disabled')
+      expect(statement.args[1].declarations[0].value).toBe(null)
       expect(statement.body).toBeInstanceOf(BlockStatement)
       expect((statement.body as BlockStatement).body.length).toBe(0)
     }

From 5b0e90ef17acb13309526b1ae0962d48ef62e77d Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Tue, 21 Nov 2023 06:32:33 -0600
Subject: [PATCH 61/64] refactor: fix comma-separated list case

---
 src/parser.ts | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 15919a0..2d04f1b 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -268,13 +268,17 @@ function parseVariable(
       j++ // skip ]
     }
 
-    j++ // skip =
+    let value: AST | null = null
 
-    const right = readUntil(',', body, j)
-    const value = parseExpression(readUntil(',', body, j)) ?? prefix
-    j += right.length
+    const delimiter = body[j++]
+    if (delimiter?.value === '=') {
+      const right = readUntil(',', body, j)
+      j += right.length
 
-    declarations.push(new VariableDeclarator(name, value))
+      value = parseExpression(right.slice(0, -1))
+    }
+
+    declarations.push(new VariableDeclarator(name, value ?? prefix))
   }
 
   return new VariableDeclaration(layout, qualifiers, kind, type, declarations)

From c1c72159e7c999789027bf16aa2d9e3508f45b3a Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Tue, 21 Nov 2023 06:34:18 -0600
Subject: [PATCH 62/64] chore: fix layout case

---
 src/parser.ts        | 2 +-
 tests/parser.test.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 2d04f1b..52f3116 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -69,7 +69,7 @@ const BINARY_OPERATORS = [
 // TODO: this is GLSL-only, separate language constants
 const TYPE_REGEX = /^(void|bool|float|u?int|[uib]?vec\d|mat\d(x\d)?)$/
 const QUALIFIER_REGEX = /^(const|uniform|in|out|inout|centroid|flat|smooth|invariant|lowp|mediump|highp)$/
-const VARIABLE_REGEX = new RegExp(`${TYPE_REGEX.source}|${QUALIFIER_REGEX.source}`)
+const VARIABLE_REGEX = new RegExp(`${TYPE_REGEX.source}|${QUALIFIER_REGEX.source}|layout`)
 
 const isDeclaration = RegExp.prototype.test.bind(VARIABLE_REGEX)
 
diff --git a/tests/parser.test.ts b/tests/parser.test.ts
index ffa7082..430cf6d 100644
--- a/tests/parser.test.ts
+++ b/tests/parser.test.ts
@@ -164,7 +164,7 @@ describe('parser', () => {
 
     {
       const statement = parse(
-        ' layout(location = 0, component = 1, column_major) flat in mat4 test;',
+        'layout(location = 0, component = 1, column_major) flat in mat4 test;',
       )[0] as VariableDeclaration
       expect(statement).toBeInstanceOf(VariableDeclaration)
       expect(statement.type).toBeInstanceOf(Type)

From 241bae7171142c5247b4be8b90d56fe0fd12d3d1 Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Tue, 21 Nov 2023 06:58:49 -0600
Subject: [PATCH 63/64] chore: cleanup

---
 src/parser.ts | 66 ---------------------------------------------------
 1 file changed, 66 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 52f3116..97e5146 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -27,7 +27,6 @@ import {
   ArrayExpression,
   PreprocessorStatement,
 } from './ast'
-import { generate } from './generator'
 import { type Token, tokenize } from './tokenizer'
 
 const UNARY_OPERATORS = ['+', '-', '~', '!', '++', '--']
@@ -567,68 +566,3 @@ export function parse(code: string): AST[] {
 
   return parseStatements()
 }
-
-const glsl = /* glsl */ `#version 300 es
-precision highp float;
-
-layout(location = 0, component = 1) flat in mat4 test;
-
-float foo = 0.0, bar = foo + 1.0, baz;
-
-struct foo {
-  bool isStruct;
-  vec4 color;
-};
-
-if (true) {
-  discard;
-} else if (false) {} else {}
-
-for (int i = 0; i < 10; i++) {}
-
-while (true) {}
-
-do {} while (true);
-
-switch(true) {
-  case 0:
-    break;
-  case 1:
-    break;
-  default:
-    break;
-}
-
-highp float method(const bool foo);
-
-void main() {
-  gl_FragColor = vec4(1, 0, 0, 1);
-}
-
-#line 0
-#define TEST 1
-#extension all: disable
-#error test
-#pragma optimize(on)
-#include <chunk>
-
-#ifdef TEST
-test;
-#endif
-
-method(true);
-
-foo.bar();
-
-const float array[3] = float[3](2.5, 7.0, 1.5);
-
-texture().rgb;
-`.trim()
-
-const ast = parse(glsl)
-const output = generate(ast, { target: 'GLSL' })
-
-console.log(glsl)
-console.log(...ast)
-console.log(output)
-console.log(glsl.replace(/\n+/g, '\n') === output)

From aec248974903ffb375f2fd1591549e171af6065a Mon Sep 17 00:00:00 2001
From: Cody Bennett <hi@codyb.co>
Date: Tue, 21 Nov 2023 08:12:23 -0600
Subject: [PATCH 64/64] chore: add compiler docs

---
 README.md        | 355 ++++++++++++++++++++++++++++++++++++++++++++++-
 src/ast.ts       | 173 +++++++++--------------
 src/generator.ts |   4 +-
 src/parser.ts    |   2 +-
 4 files changed, 419 insertions(+), 115 deletions(-)

diff --git a/README.md b/README.md
index ffba482..8d8cac6 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,41 @@
 
 Tools and IntelliSense for GLSL and WGSL.
 
+## Table of Contents
+
+- [Installation](#installation)
+- [Tokenize](#tokenize)
+- [Minify](#minify)
+- [Parse](#parse)
+- [Generate](#generate)
+- [AST](#ast)
+  - [Literal](#literal)
+  - [Identifier](#identifier)
+  - [Type](#type)
+  - [VariableDeclaration](#variabledeclaration)
+    - [VariableDeclarator](#variabledeclarator)
+  - [StructDeclaration](#structdeclaration)
+  - [FunctionDeclaration](#functiondeclaration)
+  - [UnaryExpression](#unaryexpression)
+  - [BinaryExpression](#binaryexpression)
+  - [TernaryExpression](#ternaryexpression)
+  - [CallExpression](#callexpression)
+  - [MemberExpression](#memberexpression)
+  - [ArrayExpression](#arrayexpression)
+  - [BlockStatement](#blockstatement)
+  - [IfStatement](#ifstatement)
+  - [ForStatement](#forstatement)
+  - [WhileStatement](#whilestatement)
+  - [DoWhileStatement](#dowhilestatement)
+  - [SwitchStatement](#switchstatement)
+    - [SwitchCase](#switchcase)
+  - [ReturnStatement](#returnstatement)
+  - [PreprocessorStatement](#preprocessorstatement)
+  - [PrecisionStatement](#precisionstatement)
+  - [ContinueStatement](#continuestatement)
+  - [BreakStatement](#breakstatement)
+  - [DiscardStatement](#discardstatement)
+
 ## Installation
 
 To install, use your preferred package manager:
@@ -28,6 +63,13 @@ Or, use a CDN:
 
 Tokenizes a string of GLSL or WGSL code, returning an array of `Token` objects, where each `Token` object represents a single syntax feature in the input code.
 
+```ts
+interface Token {
+  type: 'whitespace' | 'comment' | 'symbol' | 'bool' | 'float' | 'int' | 'identifier' | 'keyword'
+  value: string
+}
+```
+
 <details>
   <summary>GLSL Example</summary>
   
@@ -175,11 +217,318 @@ const minified: string = minify(code: string, {
 To shared mangled interfaces when using `mangleExternal`, declare and re-use a `mangleMap` between shaders:
 
 ```ts
-const programOpts = { mangle: true, mangleExternals: true, mangleMap: new Map() }
+const options = { mangle: true, mangleExternals: true, mangleMap: new Map() }
 
 // #version 300 es\nin vec2 a;out vec2 b;void main(){b=a;}
-minify(`#version 300 es\nin vec2 sstt;out vec2 c;void main(){c=sstt;}`, programOpts)
+minify(`#version 300 es\nin vec2 sstt;out vec2 c;void main(){c=sstt;}`, options)
 
 // #version 300 es\nin vec2 b;out vec4 a[gl_MaxDrawBuffers];void main(){a[0]=b.sstt;}
-minify(`#version 300 es\nin vec2 c;out vec4 data[gl_MaxDrawBuffers];void main(){data[0]=c.sstt;}`, programOpts)
+minify(`#version 300 es\nin vec2 c;out vec4 data[gl_MaxDrawBuffers];void main(){data[0]=c.sstt;}`, options)
+```
+
+## Parse
+
+Parses a string of GLSL (WGSL is WIP) code into an [AST](#ast).
+
+```ts
+const ast: AST[] = parse(code: string)
+```
+
+## Generate
+
+Generates a string of GLSL (WGSL is WIP) code from an [AST](#ast).
+
+```ts
+const code: string = generate(ast: AST[], {
+  target: 'GLSL' // | 'WGSL'
+})
+```
+
+## AST
+
+An [Abstract Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) loosely based on [ESTree](https://github.com/estree/estree) for GLSL and WGSL grammars.
+
+### Literal
+
+A shader literal representing a `bool`, `float`, `int`, or `uint` type.
+
+```ts
+class Literal {
+  value: string
+}
+```
+
+### Identifier
+
+A variable identifier.
+
+```ts
+class Identifier {
+  value: string
+}
+```
+
+### Type
+
+Represents a type specifier and its parameters (WGSL specific).
+
+```ts
+class Type {
+  name: string
+  parameters: (Type | Literal | Identifier)[] | null
+}
+```
+
+### VariableDeclaration
+
+A variable declaration with an optional binding layout, type qualifiers, kind (WGSL only), and declarators (e.g. a comma-separated list).
+
+```ts
+class VariableDeclaration {
+  layout: Record<string, string | boolean> | null
+  qualifiers: string[]
+  kind: 'var' | 'let' | 'const' | null
+  type: Type | Identifier
+  declarations: VariableDeclarator[]
+}
+```
+
+#### VariableDeclarator
+
+A single named declarator as part of a `VariableDeclaration`.
+
+```ts
+class VariableDeclarator {
+  name: string
+  value: AST | null
+}
+```
+
+### StructDeclaration
+
+A struct declaration. Can be used as a type or constructor.
+
+```ts
+class StructDeclaration {
+  name: string
+  members: VariableDeclaration[]
+}
+```
+
+### FunctionDeclaration
+
+A function declaration with an optional type qualifier and arguments.
+
+```ts
+class FunctionDeclaration {
+  name: string
+  type: Type | Identifier
+  qualifiers: string[]
+  args: VariableDeclaration[]
+  body: BlockStatement | null
+}
+```
+
+### UnaryExpression
+
+A unary expression with a left or right handed operator.
+
+```ts
+class UnaryExpression {
+  operator: string
+  left: AST | null
+  right: AST | null
+}
+```
+
+### BinaryExpression
+
+A binary expression with a left and right operand.
+
+```ts
+class BinaryExpression {
+  operator: string
+  left: AST
+  right: AST
+}
+```
+
+### TernaryExpression
+
+A ternary or conditional expression.
+
+```ts
+class TernaryExpression {
+  test: AST
+  consequent: AST
+  alternate: AST
+}
+```
+
+### CallExpression
+
+A call expression.
+
+```ts
+class CallExpression {
+  callee: AST
+  args: AST[]
+}
+```
+
+### MemberExpression
+
+A member expression.
+
+```ts
+class MemberExpression {
+  object: AST
+  property: AST
+}
+```
+
+### ArrayExpression
+
+An array expression. `members` can be empty if uninitialized.
+
+```ts
+class ArrayExpression {
+  type: Type
+  members: AST[]
+}
+```
+
+### BlockStatement
+
+A block statement.
+
+```ts
+class BlockStatement {
+  body: AST[]
+}
+```
+
+### IfStatement
+
+An if statement.
+
+```ts
+class IfStatement {
+  test: AST
+  consequent: AST
+  alternate: AST | null
+}
+```
+
+### ForStatement
+
+A for statement.
+
+```ts
+class ForStatement {
+  init: AST | null
+  test: AST | null
+  update: AST | null
+  body: AST
+}
+```
+
+### WhileStatement
+
+A while statement.
+
+```ts
+class WhileStatement {
+  test: AST
+  body: AST
+}
+```
+
+### DoWhileStatement
+
+A do-while statement.
+
+```ts
+class DoWhileStatement {
+  test: AST
+  body: AST
+}
+```
+
+### SwitchStatement
+
+A switch statement.
+
+```ts
+class SwitchStatement {
+  discriminant: AST
+  cases: SwitchCase[]
+}
+```
+
+#### SwitchCase
+
+A switch-case statement. `test` is null for a `default` case.
+
+```ts
+class SwitchCase {
+  test: AST | null
+  consequent: AST[]
+}
+```
+
+### ReturnStatement
+
+A return statement with an optional argument.
+
+```ts
+class ReturnStatement {
+  argument: Literal | Identifier | UnaryExpression | null
+}
+```
+
+### PreprocessorStatement
+
+A GLSL preprocessor statement with an optional value.
+
+```ts
+class PreprocessorStatement {
+  name: string
+  value: AST[] | null
+}
+```
+
+### PrecisionStatement
+
+A GLSL precision statement.
+
+```ts
+class PrecisionStatement {
+  precision: 'lowp' | 'mediump' | 'highp'
+  type: Type
+}
+```
+
+### ContinueStatement
+
+A continue statement.
+
+```ts
+class ContinueStatement {}
+```
+
+### BreakStatement
+
+A break statement.
+
+```ts
+class BreakStatement {}
+```
+
+### DiscardStatement
+
+A discard statement.
+
+```ts
+class DiscardStatement {}
 ```
diff --git a/src/ast.ts b/src/ast.ts
index 14ef40b..1f111a8 100644
--- a/src/ast.ts
+++ b/src/ast.ts
@@ -1,182 +1,137 @@
-export abstract class Node {}
-
-export class Literal extends Node {
-  constructor(public value: string /*| number | boolean*/) {
-    super()
-  }
-}
-
-export class Identifier extends Node {
-  constructor(public value: string) {
-    super()
-  }
+export class Literal {
+  constructor(public value: string /*| number | boolean*/) {}
 }
 
-export class BlockStatement extends Node {
-  constructor(public body: Node[]) {
-    super()
-  }
+export class Identifier {
+  constructor(public value: string) {}
 }
 
-export class PreprocessorStatement extends Node {
-  constructor(public name: string, public value: Node[] | null) {
-    super()
-  }
+export class Type {
+  constructor(public name: string, public parameters: (Type | Literal | Identifier)[] | null) {}
 }
 
-export class Type extends Node {
-  constructor(public name: string, public parameters: (Type | Literal | Identifier)[] | null) {
-    super()
-  }
+export class VariableDeclarator {
+  constructor(public name: string, public value: AST | null) {}
 }
 
-export class VariableDeclarator extends Node {
-  constructor(public name: string, public value: Node | null) {
-    super()
-  }
-}
-
-export class VariableDeclaration extends Node {
+export class VariableDeclaration {
   constructor(
     public layout: Record<string, string | boolean> | null,
     public qualifiers: string[],
     public kind: 'var' | 'let' | 'const' | null,
     public type: Type | Identifier,
     public declarations: VariableDeclarator[],
-  ) {
-    super()
-  }
+  ) {}
+}
+
+export class StructDeclaration {
+  constructor(public name: string, public members: VariableDeclaration[]) {}
 }
 
-export class FunctionDeclaration extends Node {
+export class FunctionDeclaration {
   constructor(
     public name: string,
     public type: Type | Identifier,
     public qualifiers: string[],
     public args: VariableDeclaration[],
     public body: BlockStatement | null,
-  ) {
-    super()
-  }
+  ) {}
 }
 
-export class CallExpression extends Node {
-  constructor(public callee: Node, public args: Node[]) {
-    super()
-  }
+export class UnaryExpression {
+  constructor(public operator: string, public left: AST | null, public right: AST | null) {}
 }
 
-export class MemberExpression extends Node {
-  constructor(public object: Node, public property: Node) {
-    super()
-  }
+export class BinaryExpression {
+  constructor(public operator: string, public left: AST, public right: AST) {}
 }
 
-export class ArrayExpression extends Node {
-  constructor(public type: Type, public members: Node[]) {
-    super()
-  }
+export class TernaryExpression {
+  constructor(public test: AST, public consequent: AST, public alternate: AST) {}
 }
 
-export class IfStatement extends Node {
-  constructor(public test: Node, public consequent: Node, public alternate: Node | null) {
-    super()
-  }
+export class CallExpression {
+  constructor(public callee: AST, public args: AST[]) {}
 }
 
-export class WhileStatement extends Node {
-  constructor(public test: Node, public body: Node) {
-    super()
-  }
+export class MemberExpression {
+  constructor(public object: AST, public property: AST) {}
 }
 
-export class ForStatement extends Node {
-  constructor(public init: Node | null, public test: Node | null, public update: Node | null, public body: Node) {
-    super()
-  }
+export class ArrayExpression {
+  constructor(public type: Type, public members: AST[]) {}
 }
 
-export class DoWhileStatement extends Node {
-  constructor(public test: Node, public body: Node) {
-    super()
-  }
+export class BlockStatement {
+  constructor(public body: AST[]) {}
 }
 
-export class SwitchCase extends Node {
-  constructor(public test: Node | null, public consequent: Node[]) {
-    super()
-  }
+export class IfStatement {
+  constructor(public test: AST, public consequent: AST, public alternate: AST | null) {}
 }
 
-export class SwitchStatement extends Node {
-  constructor(public discriminant: Node, public cases: SwitchCase[]) {
-    super()
-  }
+export class ForStatement {
+  constructor(public init: AST | null, public test: AST | null, public update: AST | null, public body: AST) {}
 }
 
-export class StructDeclaration extends Node {
-  constructor(public name: string, public members: VariableDeclaration[]) {
-    super()
-  }
+export class WhileStatement {
+  constructor(public test: AST, public body: AST) {}
 }
 
-export class UnaryExpression extends Node {
-  constructor(public operator: string, public left: Node | null, public right: Node | null) {
-    super()
-  }
+export class DoWhileStatement {
+  constructor(public test: AST, public body: AST) {}
 }
 
-export class BinaryExpression extends Node {
-  constructor(public operator: string, public left: Node, public right: Node) {
-    super()
-  }
+export class SwitchCase {
+  constructor(public test: AST | null, public consequent: AST[]) {}
 }
 
-export class TernaryExpression extends Node {
-  constructor(public test: Node, public consequent: Node, public alternate: Node) {
-    super()
-  }
+export class SwitchStatement {
+  constructor(public discriminant: AST, public cases: SwitchCase[]) {}
 }
 
-export class ReturnStatement extends Node {
-  constructor(public argument: Literal | Identifier | UnaryExpression | null) {
-    super()
-  }
+export class ReturnStatement {
+  constructor(public argument: Literal | Identifier | UnaryExpression | null) {}
 }
 
-export class ContinueStatement extends Node {}
+export class PreprocessorStatement {
+  constructor(public name: string, public value: AST[] | null) {}
+}
 
-export class BreakStatement extends Node {}
+export class PrecisionStatement {
+  constructor(public precision: 'lowp' | 'mediump' | 'highp', public type: Type) {}
+}
 
-export class DiscardStatement extends Node {}
+export class ContinueStatement {}
 
-export class PrecisionStatement extends Node {
-  constructor(public precision: 'lowp' | 'mediump' | 'highp', public type: Type) {
-    super()
-  }
-}
+export class BreakStatement {}
+
+export class DiscardStatement {}
 
 export type AST =
   | Literal
   | Identifier
+  | Type
+  | VariableDeclarator
   | VariableDeclaration
-  | BlockStatement
+  | StructDeclaration
   | FunctionDeclaration
+  | UnaryExpression
+  | BinaryExpression
+  | TernaryExpression
   | CallExpression
   | MemberExpression
   | ArrayExpression
+  | BlockStatement
   | IfStatement
-  | WhileStatement
   | ForStatement
+  | WhileStatement
   | DoWhileStatement
   | SwitchCase
   | SwitchStatement
-  | StructDeclaration
-  | UnaryExpression
-  | BinaryExpression
-  | TernaryExpression
   | ReturnStatement
+  | PreprocessorStatement
+  | PrecisionStatement
   | ContinueStatement
   | BreakStatement
   | DiscardStatement
-  | PreprocessorStatement
diff --git a/src/generator.ts b/src/generator.ts
index 394a8cf..b1abc15 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -153,11 +153,11 @@ function format(node: AST | null): string {
 }
 
 export interface GenerateOptions {
-  target: 'GLSL' | 'WGSL'
+  target: 'GLSL' // | 'WGSL'
 }
 
 /**
- * Generates a string of GLSL or WGSL code from an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
+ * Generates a string of GLSL (WGSL WIP) code from an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
  */
 export function generate(ast: AST[], options: GenerateOptions): string {
   let code = '#version 300 es\n'
diff --git a/src/parser.ts b/src/parser.ts
index 97e5146..3bb484b 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -551,7 +551,7 @@ function parseBlock(): BlockStatement {
 const DIRECTIVE_REGEX = /(^\s*#[^\\]*?)(\n|\/[\/\*])/gm
 
 /**
- * Parses a string of GLSL or WGSL code into an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
+ * Parses a string of GLSL (WGSL WIP) code into an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
  */
 export function parse(code: string): AST[] {
   // Remove (implicit) version header