fix: Error when resolving raw external array

Author: iwoplaza

packages/typegpu/src/resolutionCtx.ts

@@ -970,14 +970,6 @@ export class ResolutionCtxImpl implements ResolutionCtx {
       );
     }
 
-    if (Array.isArray(item)) {
-      return snip(
-        stitch`array(${item.map((element) => this.resolve(element))})`,
-        UnknownData,
-        /* origin */ 'runtime',
-      ) as ResolvedSnippet;
-    }
-
     if (schema && isWgslStruct(schema)) {
       return snip(
         stitch`${this.resolve(schema)}(${Object.entries(schema.propTypes).map(([key, propType]) =>
@@ -989,7 +981,7 @@ export class ResolutionCtxImpl implements ResolutionCtx {
     }
 
     throw new WgslTypeError(
-      `Value ${item} (as json: ${safeStringify(item)}) is not resolvable${
+      `Value ${safeStringify(item)} is not resolvable${
         schema ? ` to type ${safeStringify(schema)}` : ''
       }`,
     );

packages/typegpu/src/shared/stringify.ts

@@ -1,6 +1,10 @@
 import { isMatInstance, isVecInstance } from '../data/wgslTypes.ts';
 
 export function safeStringify(item: unknown): string {
+  if (Array.isArray(item)) {
+    return `[${item.map(safeStringify).join(', ')}]`;
+  }
+
   const asString = String(item);
   if (asString !== '[object Object]') {
     return asString;

packages/typegpu/tests/array.test.ts

@@ -193,18 +193,21 @@ describe('array', () => {
   it('generates correct code when array clone is used', () => {
     const ArraySchema = d.arrayOf(d.u32, 1);
 
-    const f = (arr: d.Infer<typeof ArraySchema>) => {
+    function f(arr: d.InferGPU<typeof ArraySchema>) {
       'use gpu';
       const clone = ArraySchema(arr);
-    };
+    }
 
-    const testFn = () => {
+    const external = [3];
+
+    function testFn() {
       'use gpu';
       const myArray = ArraySchema([d.u32(10)]);
       const myClone = ArraySchema(myArray);
+      const myExternal = ArraySchema(external);
       f(myArray);
       return;
-    };
+    }
 
     expect(tgpu.resolve([testFn])).toMatchInlineSnapshot(`
       "fn f(arr: array<u32, 1>) {
@@ -214,6 +217,7 @@ describe('array', () => {
       fn testFn() {
         var myArray = array<u32, 1>(10u);
         var myClone = myArray;
+        var myExternal = array<u32, 1>(3u);
         f(myArray);
         return;
       }"
@@ -538,6 +542,21 @@ describe('array', () => {
       }"
     `);
   });
+
+  it('throws when trying to resolve an untyped external array', () => {
+    const arr = [1, 2, 3];
+    function main() {
+      'use gpu';
+      arr;
+    }
+
+    expect(() => tgpu.resolve([main])).toThrowErrorMatchingInlineSnapshot(`
+      [Error: Resolution of the following tree failed:
+      - <root>
+      - fn*:main
+      - fn*:main(): Value [1, 2, 3] is not resolvable]
+    `);
+  });
 });
 
 describe('array.length', () => {