fix: Error when resolving raw external array

Author: iwoplaza

packages/typegpu/src/resolutionCtx.ts

@@ -953,14 +953,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]) =>
@@ -972,7 +964,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

@@ -192,18 +192,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 external = [3];
 
-    const testFn = () => {
+    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>) {
@@ -213,6 +216,7 @@ describe('array', () => {
       fn testFn() {
         var myArray = array<u32, 1>(10u);
         var myClone = myArray;
+        var myExternal = array<u32, 1>(3u);
         f(myArray);
         return;
       }"
@@ -443,6 +447,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', () => {

packages/typegpu/tests/tgsl/wgslGenerator.test.ts

@@ -1757,7 +1757,7 @@ describe('wgslGenerator', () => {
     expect(() => tgpu.resolve([testFn])).toThrowErrorMatchingInlineSnapshot(`
       [Error: Resolution of the following tree failed:
       - <root>
-      - fn:testFn: Value undefined (as json: undefined) is not resolvable to type u32]
+      - fn:testFn: Value undefined is not resolvable to type u32]
     `);
   });