fix: Lift limitation on passing tgpu.const references as arguments (#2286)

Author: iwoplaza

packages/typegpu/src/tgsl/shellless.ts

@@ -4,7 +4,6 @@ import { RefOperator } from '../data/ref.ts';
 import type { Snippet } from '../data/snippet.ts';
 import { type BaseData, isPtr, isWgslArray, isWgslStruct } from '../data/wgslTypes.ts';
 import { WgslTypeError } from '../errors.ts';
-import { getResolutionCtx } from '../execMode.ts';
 import { getMetaData, getName } from '../shared/meta.ts';
 import { concretize } from './generationHelpers.ts';
 
@@ -64,16 +63,6 @@ export class ShelllessRepository {
 
       let type = concretize(s.dataType);
 
-      if (s.origin === 'constant-tgpu-const-ref' || s.origin === 'runtime-tgpu-const-ref') {
-        // oxlint-disable-next-line typescript/no-non-null-assertion -- it's there
-        const ctx = getResolutionCtx()!;
-        throw new Error(
-          `Cannot pass constant references as function arguments. Explicitly copy them by wrapping them in a schema: '${
-            ctx.resolve(type).value
-          }(...)'`,
-        );
-      }
-
       if (isPtr(type) && type.implicit) {
         // If the pointer was made implicitly (e.g. by assigning a reference to a const variable),
         // then we dereference the pointer before passing it to the function. The main reason for this,

packages/typegpu/tests/constant.test.ts

@@ -46,7 +46,7 @@ describe('tgpu.const', () => {
     `);
   });
 
-  it('cannot be passed directly to shellless functions', () => {
+  it('can be passed directly to shellless functions (as arguments cannot be mutated anyway)', () => {
     const fn1 = (v: d.v3f) => {
       'use gpu';
       return v.x * v.y * v.z;
@@ -58,11 +58,16 @@ describe('tgpu.const', () => {
       return fn1(foo.$);
     };
 
-    expect(() => tgpu.resolve([fn2])).toThrowErrorMatchingInlineSnapshot(`
-      [Error: Resolution of the following tree failed:
-      - <root>
-      - fn*:fn2
-      - fn*:fn2(): Cannot pass constant references as function arguments. Explicitly copy them by wrapping them in a schema: 'vec3f(...)']
+    expect(tgpu.resolve([fn2])).toMatchInlineSnapshot(`
+      "fn fn1(v: vec3f) -> f32 {
+        return ((v.x * v.y) * v.z);
+      }
+
+      const foo: vec3f = vec3f(1, 2, 3);
+
+      fn fn2() -> f32 {
+        return fn1(foo);
+      }"
     `);
   });
 
@@ -116,49 +121,4 @@ describe('tgpu.const', () => {
       }"
     `);
   });
-
-  it('cannot be passed directly to shellless functions', () => {
-    const fn1 = (v: d.v3f) => {
-      'use gpu';
-      return v.x * v.y * v.z;
-    };
-
-    const foo = tgpu.const(d.vec3f, d.vec3f(1, 2, 3));
-    const fn2 = () => {
-      'use gpu';
-      return fn1(foo.$);
-    };
-
-    expect(() => tgpu.resolve([fn2])).toThrowErrorMatchingInlineSnapshot(`
-      [Error: Resolution of the following tree failed:
-      - <root>
-      - fn*:fn2
-      - fn*:fn2(): Cannot pass constant references as function arguments. Explicitly copy them by wrapping them in a schema: 'vec3f(...)']
-    `);
-  });
-
-  it('cannot be mutated', () => {
-    const boid = tgpu.const(Boid, {
-      pos: d.vec3f(1, 2, 3),
-      vel: d.vec3u(4, 5, 6),
-    });
-
-    const fn = () => {
-      'use gpu';
-      // @ts-expect-error: Cannot assign to read-only property
-      boid.$.pos = d.vec3f(0, 0, 0);
-    };
-
-    expect(() => tgpu.resolve([fn])).toThrowErrorMatchingInlineSnapshot(`
-      [Error: Resolution of the following tree failed:
-      - <root>
-      - fn*:fn
-      - fn*:fn(): 'boid.pos = vec3f()' is invalid, because boid.pos is a constant. This error may also occur when assigning to a value defined outside of a TypeGPU function's scope.]
-    `);
-
-    // Since we freeze the object, we cannot mutate when running the function in JS either
-    expect(() => fn()).toThrowErrorMatchingInlineSnapshot(
-      `[TypeError: Cannot assign to read only property 'pos' of object '#<Object>']`,
-    );
-  });
 });