shaderkit 0.6.4 → 0.8.0

package/src/generator.ts

@@ -1,128 +1,128 @@
-import { type AST, type Program } from './ast.js'
-
-function formatLayout(layout: Record<string, string | boolean> | null): string {
-  if (!layout) return ''
-
-  return `layout(${Object.entries(layout)
-    .map(([k, v]) => (v === true ? k : `${k}=${v}`))
-    .join(',')})`
-}
-
-// TODO: restore comments/whitespace with sourcemaps, WGSL support
-function format(node: AST | null): string {
-  if (!node) return ''
-
-  switch (node.type) {
-    case 'Identifier':
-      return node.name
-    case 'Literal':
-      return node.value
-    case 'ArraySpecifier':
-      return `${node.typeSpecifier.name}${node.dimensions.map((d) => `[${format(d)}]`).join('')}`
-    case 'ExpressionStatement':
-      return `${format(node.expression)};`
-    case 'BlockStatement':
-      return `{${node.body.map(format).join('')}}`
-    case 'DiscardStatement':
-      return 'discard;'
-    case 'PreprocessorStatement': {
-      let value = ''
-      if (node.value) {
-        if (node.name === 'include') value = ` <${format(node.value[0])}>` // three is whitespace sensitive
-        else if (node.name === 'extension') value = ` ${node.value.map(format).join(':')}`
-        else if (node.value.length) value = ` ${node.value.map(format).join(' ')}`
-      }
-
-      return `\n#${node.name}${value}\n`
-    }
-    case 'PrecisionQualifierStatement':
-      return `precision ${node.precision} ${node.typeSpecifier.name};`
-    case 'InvariantQualifierStatement':
-      return `invariant ${format(node.typeSpecifier)};`
-    case 'LayoutQualifierStatement':
-      return `${formatLayout(node.layout)}${node.qualifier};`
-    case 'ReturnStatement':
-      return node.argument ? `return ${format(node.argument)};` : 'return;'
-    case 'BreakStatement':
-      return 'break;'
-    case 'ContinueStatement':
-      return 'continue;'
-    case 'IfStatement': {
-      const alternate = node.alternate ? ` else${format(node.consequent)}` : ''
-      return `if(${format(node.test)})${format(node.consequent)}${alternate}`
-    }
-    case 'SwitchStatement':
-      return `switch(${format(node.discriminant)}){${node.cases.map(format).join('')}}`
-    case 'SwitchCase':
-      return `case ${node.test ? format(node.test) : 'default'}:{${node.consequent.map(format).join(';')}}`
-    case 'WhileStatement':
-      return `while (${format(node.test)}) ${format(node.body)}`
-    case 'DoWhileStatement':
-      return `do ${format(node.body)}while(${format(node.test)})`
-    case 'ForStatement':
-      return `for(${format(node.init)};${format(node.test)};${format(node.update)})${format(node.body)}`
-    case 'FunctionDeclaration': {
-      const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : '' // precision
-      const body = node.body ? format(node.body) : ';'
-      return `${qualifiers}${format(node.typeSpecifier)} ${format(node.id)}(${node.params
-        .map(format)
-        .join(',')})${body}`
-    }
-    case 'FunctionParameter': {
-      const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : ''
-      const id = node.id ? ` ${format(node.id)}` : ''
-      return `${qualifiers}${format(node.typeSpecifier)}${id}`
-    }
-    case 'VariableDeclaration': {
-      const head = node.declarations[0]
-      const layout = formatLayout(head.layout)
-      const qualifiers = head.qualifiers.length ? `${head.qualifiers.join(' ')} ` : ''
-      return `${layout}${qualifiers}${format(head.typeSpecifier)} ${node.declarations.map(format).join(',')};`
-    }
-    case 'VariableDeclarator': {
-      const init = node.init ? `=${format(node.init)}` : ''
-      return `${format(node.id)}${init}`
-    }
-    case 'StructuredBufferDeclaration': {
-      const layout = formatLayout(node.layout)
-      const scope = node.id ? `${format(node.id)}` : ''
-      return `${layout}${node.qualifiers.join(' ')} ${format(node.typeSpecifier)}{${node.members
-        .map(format)
-        .join('')}}${scope};`
-    }
-    case 'StructDeclaration':
-      return `struct ${format(node.id)}{${node.members.map(format).join('')}};`
-    case 'ArrayExpression':
-      return `${format(node.typeSpecifier)}(${node.elements.map(format).join(',')})`
-    case 'UnaryExpression':
-    case 'UpdateExpression':
-      return node.prefix ? `${node.operator}${format(node.argument)}` : `${format(node.argument)}${node.operator}`
-    case 'BinaryExpression':
-    case 'AssignmentExpression':
-    case 'LogicalExpression':
-      return `${format(node.left)}${node.operator}${format(node.right)}`
-    case 'MemberExpression':
-      return node.computed
-        ? `${format(node.object)}[${format(node.property)}]`
-        : `${format(node.object)}.${format(node.property)}`
-    case 'ConditionalExpression':
-      return `${format(node.test)}?${format(node.alternate)}:${format(node.consequent)}`
-    case 'CallExpression':
-      return `${format(node.callee)}(${node.arguments.map(format).join(',')})`
-    case 'Program':
-      return `${node.body.map(format).join('')}`
-    default:
-      return node satisfies never
-  }
-}
-
-export interface GenerateOptions {
-  target: 'GLSL' // | 'WGSL'
-}
-
-/**
- * Generates a string of GLSL (WGSL WIP) code from an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
- */
-export function generate(program: Program, options: GenerateOptions): string {
-  return format(program).replaceAll('\n\n', '\n').replaceAll('] ', ']').trim()
-}
+import { type AST, type Program } from './ast.js'
+
+function formatLayout(layout: Record<string, string | boolean> | null): string {
+  if (!layout) return ''
+
+  return `layout(${Object.entries(layout)
+    .map(([k, v]) => (v === true ? k : `${k}=${v}`))
+    .join(',')})`
+}
+
+// TODO: restore comments/whitespace with sourcemaps, WGSL support
+function format(node: AST | null): string {
+  if (!node) return ''
+
+  switch (node.type) {
+    case 'Identifier':
+      return node.name
+    case 'Literal':
+      return node.value
+    case 'ArraySpecifier':
+      return `${node.typeSpecifier.name}${node.dimensions.map((d) => `[${format(d)}]`).join('')}`
+    case 'ExpressionStatement':
+      return `${format(node.expression)};`
+    case 'BlockStatement':
+      return `{${node.body.map(format).join('')}}`
+    case 'DiscardStatement':
+      return 'discard;'
+    case 'PreprocessorStatement': {
+      let value = ''
+      if (node.value) {
+        if (node.name === 'include') value = ` <${format(node.value[0])}>` // three is whitespace sensitive
+        else if (node.name === 'extension') value = ` ${node.value.map(format).join(':')}`
+        else if (node.value.length) value = ` ${node.value.map(format).join(' ')}`
+      }
+
+      return `\n#${node.name}${value}\n`
+    }
+    case 'PrecisionQualifierStatement':
+      return `precision ${node.precision} ${node.typeSpecifier.name};`
+    case 'InvariantQualifierStatement':
+      return `invariant ${format(node.typeSpecifier)};`
+    case 'LayoutQualifierStatement':
+      return `${formatLayout(node.layout)}${node.qualifier};`
+    case 'ReturnStatement':
+      return node.argument ? `return ${format(node.argument)};` : 'return;'
+    case 'BreakStatement':
+      return 'break;'
+    case 'ContinueStatement':
+      return 'continue;'
+    case 'IfStatement': {
+      const alternate = node.alternate ? ` else${format(node.consequent)}` : ''
+      return `if(${format(node.test)})${format(node.consequent)}${alternate}`
+    }
+    case 'SwitchStatement':
+      return `switch(${format(node.discriminant)}){${node.cases.map(format).join('')}}`
+    case 'SwitchCase':
+      return `case ${node.test ? format(node.test) : 'default'}:{${node.consequent.map(format).join(';')}}`
+    case 'WhileStatement':
+      return `while (${format(node.test)}) ${format(node.body)}`
+    case 'DoWhileStatement':
+      return `do ${format(node.body)}while(${format(node.test)})`
+    case 'ForStatement':
+      return `for(${format(node.init)};${format(node.test)};${format(node.update)})${format(node.body)}`
+    case 'FunctionDeclaration': {
+      const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : '' // precision
+      const body = node.body ? format(node.body) : ';'
+      return `${qualifiers}${format(node.typeSpecifier)} ${format(node.id)}(${node.params
+        .map(format)
+        .join(',')})${body}`
+    }
+    case 'FunctionParameter': {
+      const qualifiers = node.qualifiers.length ? `${node.qualifiers.join(' ')} ` : ''
+      const id = node.id ? ` ${format(node.id)}` : ''
+      return `${qualifiers}${format(node.typeSpecifier)}${id}`
+    }
+    case 'VariableDeclaration': {
+      const head = node.declarations[0]
+      const layout = formatLayout(head.layout)
+      const qualifiers = head.qualifiers.length ? `${head.qualifiers.join(' ')} ` : ''
+      return `${layout}${qualifiers}${format(head.typeSpecifier)} ${node.declarations.map(format).join(',')};`
+    }
+    case 'VariableDeclarator': {
+      const init = node.init ? `=${format(node.init)}` : ''
+      return `${format(node.id)}${init}`
+    }
+    case 'StructuredBufferDeclaration': {
+      const layout = formatLayout(node.layout)
+      const scope = node.id ? `${format(node.id)}` : ''
+      return `${layout}${node.qualifiers.join(' ')} ${format(node.typeSpecifier)}{${node.members
+        .map(format)
+        .join('')}}${scope};`
+    }
+    case 'StructDeclaration':
+      return `struct ${format(node.id)}{${node.members.map(format).join('')}};`
+    case 'ArrayExpression':
+      return `${format(node.typeSpecifier)}(${node.elements.map(format).join(',')})`
+    case 'UnaryExpression':
+    case 'UpdateExpression':
+      return node.prefix ? `${node.operator}${format(node.argument)}` : `${format(node.argument)}${node.operator}`
+    case 'BinaryExpression':
+    case 'AssignmentExpression':
+    case 'LogicalExpression':
+      return `${format(node.left)}${node.operator}${format(node.right)}`
+    case 'MemberExpression':
+      return node.computed
+        ? `${format(node.object)}[${format(node.property)}]`
+        : `${format(node.object)}.${format(node.property)}`
+    case 'ConditionalExpression':
+      return `${format(node.test)}?${format(node.alternate)}:${format(node.consequent)}`
+    case 'CallExpression':
+      return `${format(node.callee)}(${node.arguments.map(format).join(',')})`
+    case 'Program':
+      return `${node.body.map(format).join('')}`
+    default:
+      return node satisfies never
+  }
+}
+
+export interface GenerateOptions {
+  target: 'GLSL' // | 'WGSL'
+}
+
+/**
+ * Generates a string of GLSL (WGSL WIP) code from an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
+ */
+export function generate(program: Program, options: GenerateOptions): string {
+  return format(program).replaceAll('\n\n', '\n').replaceAll('] ', ']').trim()
+}

package/src/hoister.ts

@@ -0,0 +1,171 @@
+import type { Token } from './tokenizer.js'
+
+export interface HoistNode {
+  prefix: Token[]
+  cases: { cond: Token[]; node: HoistNode }[]
+}
+
+/**
+ * A set of tokens optionally starting with a directive
+ */
+type PreprocessorSegment = {
+  directive?: Token[] | undefined
+  suffix: Token[]
+  scope: number
+}
+
+const preScopeDelta = {
+  if: 1,
+  ifdef: 1,
+  ifndef: 1,
+} as Record<string, number>
+
+const postScopeDelta = {
+  endif: -1,
+} as Record<string, number>
+
+export function segmentDirectives(tokens: Token[]): PreprocessorSegment[] {
+  const segments: PreprocessorSegment[] = []
+
+  // Gathering the first non-directive segment, if it exists
+  let cursor = 0
+  let scope = 0
+  const prefix: Token[] = []
+  while (cursor < tokens.length && tokens[cursor].value !== '#') {
+    prefix.push(tokens[cursor++])
+  }
+
+  if (prefix.length > 0) {
+    segments.push({ suffix: trimWhitespace(prefix), scope })
+  }
+
+  while (cursor < tokens.length) {
+    const directive: Token[] = []
+    while (cursor < tokens.length && tokens[cursor].value !== '\\') {
+      directive.push(tokens[cursor++])
+    }
+    directive.push(tokens[cursor++]) // push the '\\'
+
+    const suffix: Token[] = []
+    while (cursor < tokens.length && tokens[cursor].value !== '#') {
+      suffix.push(tokens[cursor++])
+    }
+
+    const name = directive[1]?.value ?? ''
+    scope += preScopeDelta[name] || 0
+    segments.push({ directive, suffix: trimWhitespace(suffix), scope })
+    scope += postScopeDelta[name] || 0
+  }
+
+  return segments
+}
+
+export function getDirectiveName(segment: PreprocessorSegment): string {
+  return segment.directive?.[1]?.value ?? ''
+}
+
+export function trimWhitespace(tokens: Token[]): Token[] {
+  let start = 0
+  let end = tokens.length - 1
+
+  if (end === 0 && tokens[0].type === 'whitespace') {
+    return []
+  }
+
+  while (start < end && tokens[start].type === 'whitespace') {
+    start++
+  }
+
+  while (end > start && tokens[end].type === 'whitespace') {
+    end--
+  }
+
+  return tokens.slice(start, end + 1)
+}
+
+function constructHoistTree(
+  segments: PreprocessorSegment[],
+  scope: number = 0,
+  remainder: HoistNode | undefined = undefined,
+): HoistNode {
+  let leafNode: HoistNode = {
+    cases: remainder?.cases ?? [],
+    prefix: remainder?.prefix ?? [],
+  }
+
+  let currentNode: HoistNode | undefined
+  // The segment index that marks the end of the currently
+  // explored case (exclusive)
+  let caseEnd = segments.length - 1
+
+  for (let seg = segments.length - 1; seg >= 0; seg--) {
+    const segment = segments[seg]
+    if (segment.scope === scope) {
+      // A segment that belongs to the outer scope, meaning we're at the top of the nested node
+      leafNode.prefix = [...segment.suffix, ...leafNode.prefix]
+      continue
+    }
+
+    if (segment.scope > scope + 1) {
+      continue // A nested segment, skip it
+    }
+
+    const name = getDirectiveName(segment)
+    if (name === '') {
+      // The first segment, no directive
+      if (leafNode) {
+        leafNode.prefix = [...segment.suffix, ...leafNode.prefix]
+      }
+    } else if (name === 'endif') {
+      // Prepending the suffix of the endif segment before the leaf node
+      leafNode.prefix = [...segment.suffix, ...leafNode.prefix]
+      caseEnd = seg
+      currentNode = {
+        cases: [],
+        prefix: [],
+      }
+    } else if (name === 'else' || name === 'elif' || name === 'if' || name === 'ifdef' || name === 'ifndef') {
+      const caseNode = constructHoistTree(segments.slice(seg, caseEnd), scope + 1, leafNode)
+      caseEnd = seg // the next ends where the previous started
+      currentNode?.cases.unshift({ cond: segment.directive ?? [], node: caseNode })
+    }
+
+    if (name === 'if' || name === 'ifdef' || name === 'ifndef') {
+      // We're finishing up a whole node
+      leafNode = currentNode!
+    }
+  }
+
+  // No nested conditions in this node
+  return leafNode
+}
+
+function flattenHoistNode(node: HoistNode, prefix: Token[]): Token[] {
+  if (node.cases.length === 0) {
+    return [...prefix, ...node.prefix]
+  }
+
+  return [
+    ...node.cases.flatMap((case_) => {
+      return [
+        ...case_.cond,
+        { type: 'whitespace' as const, value: '\n' },
+        ...flattenHoistNode(case_.node, [...prefix, ...node.prefix]),
+        { type: 'whitespace' as const, value: '\n' },
+      ]
+    }),
+    { type: 'symbol', value: '#' },
+    { type: 'keyword', value: 'endif' },
+    { type: 'symbol' as const, value: '\\' },
+    { type: 'whitespace' as const, value: '\n' },
+  ]
+}
+
+/**
+ * Hoists preprocessor directives on the token level
+ */
+export function hoistPreprocessorDirectives(tokens: Token[]): Token[] {
+  const tree = constructHoistTree(segmentDirectives(tokens))
+
+  return flattenHoistNode(tree, [])
+}

package/src/index.ts

@@ -1,7 +1,7 @@
-export * from './ast.js'
-export * from './constants.js'
-export * from './generator.js'
-export * from './minifier.js'
-export * from './parser.js'
-export * from './tokenizer.js'
-export * from './visitor.js'
+export * from './ast.js'
+export * from './constants.js'
+export * from './generator.js'
+export * from './minifier.js'
+export * from './parser.js'
+export * from './tokenizer.js'
+export * from './visitor.js'