Merge branch 'test/incorporate-arkattest-for-checking-infer' of https://github.com/software-mansion/TypeGPU into test/incorporate-arkattest-for-checking-infer

Author: iwoplaza

packages/tgpu-jit/package.json

@@ -57,6 +57,6 @@
   "dependencies": {
     "acorn": "^8.14.1",
     "tinyest": "workspace:~0.1.0-alpha.7",
-    "tinyest-for-wgsl": "workspace:~0.1.0-alpha.8"
+    "tinyest-for-wgsl": "workspace:~0.1.0-alpha.9"
   }
 }

packages/tinyest-for-wgsl/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tinyest-for-wgsl",
   "private": true,
-  "version": "0.1.0-alpha.8",
+  "version": "0.1.0-alpha.9",
   "description": "Transforms JavaScript into its 'tinyest' form, to be used in generating equivalent (or close to) WGSL code.",
   "license": "MIT",
   "type": "module",

packages/tinyest-for-wgsl/src/parsers.ts

@@ -447,7 +447,7 @@ export function extractFunctionParts(rootNode: JsNode): {
       params: {
         type: 'destructured-object',
         props: functionNode.params[0].properties.flatMap((prop) =>
-          prop.type === 'Property' &&
+          (prop.type === 'Property' || prop.type === 'ObjectProperty') &&
           prop.key.type === 'Identifier' &&
           prop.value.type === 'Identifier'
             ? [{ prop: prop.key.name, alias: prop.value.name }]

packages/tinyest-for-wgsl/tests/parsers.test.ts

@@ -1,6 +1,7 @@
 import babel from '@babel/parser';
 import type { Node } from '@babel/types';
 import * as acorn from 'acorn';
+import type { ArgNames } from 'tinyest';
 import { describe, expect, it } from 'vitest';
 import { transpileFn } from '../src/parsers.ts';
 
@@ -142,4 +143,31 @@ describe('transpileFn', () => {
       expect(externalNames).toEqual(['external']);
     }),
   );
+
+  it(
+    'handles destructured args',
+    dualTest((p) => {
+      const { argNames, externalNames } = transpileFn(
+        p(`({ pos, a: b }) => {
+          const x = pos.x;
+        }`),
+      );
+
+      expect(argNames).toEqual({
+        type: 'destructured-object',
+        props: [
+          {
+            alias: 'pos',
+            prop: 'pos',
+          },
+          {
+            alias: 'b',
+            prop: 'a',
+          },
+        ],
+      } satisfies ArgNames);
+
+      expect(externalNames).toEqual([]);
+    }),
+  );
 });

packages/typegpu/src/core/function/fnCore.ts

@@ -175,9 +175,12 @@ export function createFnCore(
 
         const args: Snippet[] = Array.isArray(shell.argTypes)
           ? ast.argNames.type === 'identifiers'
-            ? ast.argNames.names.map((name, idx) => ({
-                value: name,
-                dataType: (shell.argTypes as unknown[])[idx] as AnyWgslData,
+            ? shell.argTypes.map((arg, i) => ({
+                value:
+                  (ast.argNames.type === 'identifiers'
+                    ? ast.argNames.names[i]
+                    : undefined) ?? `arg_${i}`,
+                dataType: arg as AnyWgslData,
               }))
             : []
           : Object.entries(shell.argTypes).map(([name, dataType]) => ({

packages/typegpu/src/core/function/tgpuComputeFn.ts

@@ -17,7 +17,7 @@ import { stripTemplate } from './templateUtils.ts';
 type TgpuComputeFnShellHeader<
   ComputeIn extends Record<string, AnyComputeBuiltin>,
 > = {
-  readonly argTypes: [AnyWgslStruct];
+  readonly argTypes: [AnyWgslStruct] | [];
   readonly returnType: undefined;
   readonly workgroupSize: [number, number, number];
   readonly isEntry: true;
@@ -105,7 +105,10 @@ export function computeFn<
   workgroupSize: number[];
 }): TgpuComputeFnShell<ComputeIn> {
   const shell: TgpuComputeFnShellHeader<ComputeIn> = {
-    argTypes: [createStructFromIO(options.in ?? {})],
+    argTypes:
+      options.in && Object.keys(options.in).length !== 0
+        ? [createStructFromIO(options.in)]
+        : [],
     returnType: undefined,
     workgroupSize: [
       options.workgroupSize[0] ?? 1,

packages/typegpu/src/core/function/tgpuFragmentFn.ts

@@ -53,7 +53,7 @@ type TgpuFragmentFnShellHeader<
   FragmentIn extends FragmentInConstrained,
   FragmentOut extends FragmentOutConstrained,
 > = {
-  readonly argTypes: [AnyWgslStruct];
+  readonly argTypes: [AnyWgslStruct] | [];
   readonly targets: FragmentOut;
   readonly returnType: FragmentOut;
   readonly isEntry: true;
@@ -149,9 +149,14 @@ export function fragmentFn<
   out: FragmentOut;
 }): TgpuFragmentFnShell<FragmentIn, FragmentOut> {
   const shell: TgpuFragmentFnShellHeader<FragmentIn, FragmentOut> = {
-    argTypes: [createStructFromIO(options.in ?? {})],
+    argTypes:
+      options.in && Object.keys(options.in).length !== 0
+        ? [createStructFromIO(options.in)]
+        : [],
     targets: options.out,
-    returnType: createOutputType(options.out) as FragmentOut,
+    returnType: (Object.keys(options.out).length !== 0
+      ? createOutputType(options.out)
+      : undefined) as FragmentOut,
     isEntry: true,
   };
 

packages/typegpu/src/core/function/tgpuVertexFn.ts

@@ -24,7 +24,7 @@ type TgpuVertexFnShellHeader<
   VertexIn extends IOLayout,
   VertexOut extends IOLayout,
 > = {
-  readonly argTypes: [AnyWgslStruct];
+  readonly argTypes: [AnyWgslStruct] | [];
   readonly returnType: VertexOut;
   readonly attributes: [VertexIn];
   readonly isEntry: true;
@@ -108,8 +108,13 @@ export function vertexFn<
 }): TgpuVertexFnShell<VertexIn, VertexOut> {
   const shell: TgpuVertexFnShellHeader<VertexIn, VertexOut> = {
     attributes: [options.in ?? ({} as VertexIn)],
-    returnType: createOutputType(options.out) as unknown as VertexOut,
-    argTypes: [createStructFromIO(options.in ?? {})],
+    returnType: (Object.keys(options.out).length !== 0
+      ? createOutputType(options.out)
+      : undefined) as unknown as VertexOut,
+    argTypes:
+      options.in && Object.keys(options.in).length !== 0
+        ? [createStructFromIO(options.in)]
+        : [],
     isEntry: true,
   };
 

packages/typegpu/tests/function.test.ts

@@ -141,6 +141,106 @@ describe('tgpu.fn', () => {
   });
 });
 
+describe('tgpu.computeFn', () => {
+  it('does not create In struct when the are no arguments', () => {
+    const foo = tgpu['~unstable'].computeFn({ workgroupSize: [1] })(() => {
+      const x = 2;
+    });
+
+    expect(parseResolved({ foo })).not.toContain('struct');
+    expect(foo.shell.argTypes).toEqual([]);
+  });
+
+  it('does not create In struct when there is empty object for arguments', () => {
+    const foo = tgpu['~unstable'].computeFn({ in: {}, workgroupSize: [1] })(
+      () => {
+        const x = 2;
+      },
+    );
+
+    expect(parseResolved({ foo })).not.toContain(parse('struct'));
+    expect(foo.shell.argTypes).toEqual([]);
+  });
+});
+
+describe('tgpu.vertexFn', () => {
+  it('does not create In struct when the are no arguments', () => {
+    const foo = tgpu['~unstable'].vertexFn({
+      out: { pos: d.builtin.position },
+    })(() => ({
+      pos: d.vec4f(),
+    }));
+    expect(parseResolved({ foo })).not.toContain(parse('struct foo_In'));
+    expect(parseResolved({ foo })).toContain(parse('struct foo_Out'));
+    expect(foo.shell.argTypes).toEqual([]);
+  });
+
+  it('does not create In struct when there is empty object for arguments', () => {
+    const foo = tgpu['~unstable'].vertexFn({
+      in: {},
+      out: { pos: d.builtin.position },
+    })(() => {
+      return {
+        pos: d.vec4f(),
+      };
+    });
+    expect(parseResolved({ foo })).not.toContain(parse('struct foo_In'));
+    expect(parseResolved({ foo })).toContain(parse('struct foo_Out'));
+    expect(foo.shell.argTypes).toEqual([]);
+  });
+
+  it('does not create In struct when there is empty object for arguments', () => {
+    const foo = tgpu['~unstable'].vertexFn({
+      in: {},
+      out: { pos: d.builtin.position },
+    })(() => {
+      return {
+        pos: d.vec4f(),
+      };
+    });
+    expect(parseResolved({ foo })).not.toContain(parse('struct foo_In'));
+    expect(parseResolved({ foo })).toContain(parse('struct foo_Out'));
+    expect(foo.shell.argTypes).toEqual([]);
+  });
+
+  it('does not create Out struct when the are no output parameters', () => {
+    const foo = tgpu['~unstable'].vertexFn({
+      out: {},
+    })(() => ({
+      pos: d.vec4f(),
+    }));
+    expect(parseResolved({ foo })).not.toContain(parse('struct foo_Out'));
+  });
+});
+
+describe('tgpu.fragmentFn', () => {
+  it('does not create In struct when the are no arguments', () => {
+    const foo = tgpu['~unstable'].fragmentFn({
+      out: d.vec4f,
+    })(() => d.vec4f(0));
+
+    expect(parseResolved({ foo })).not.toContain(parse('struct'));
+    expect(foo.shell.argTypes).toEqual([]);
+  });
+
+  it('does not create In struct when there is empty object for arguments', () => {
+    const foo = tgpu['~unstable'].fragmentFn({
+      in: {},
+      out: d.vec4f,
+    })(() => d.vec4f(0));
+
+    expect(parseResolved({ foo })).not.toContain(parse('struct'));
+    expect(foo.shell.argTypes).toEqual([]);
+  });
+
+  it('does not create Out struct when the are no output parameters', () => {
+    const foo = tgpu['~unstable'].fragmentFn({
+      out: {},
+    })(() => ({}));
+    expect(parseResolved({ foo })).not.toContain(parse('struct foo_Out'));
+  });
+});
+
 describe('InferIO', () => {
   it('unwraps f32', () => {
     const layout = d.f32 satisfies IOLayout;