impr: Origin chain

const a = 1;
return a;

[..., i32, 'constant']

[..., i32, snippet(1, i32, 'constant')]

It is required for the d.ref case mentioned above

const a = 1;
const b = a;
return b;

[..., i32, 'constant']

[..., i32, snippet(1, i32, 'constant')]

 Note that b 'references' a in the code, but the origin points
 to the highest snippet in the chain.

fn([i32])((a) => return a);

[..., i32, 'argument']

[..., i32, 'argument']

Non-ref arguments are copied, so a is the highest origin

fn([i32])((a) => {
  const b = a;
  return b;
})

[..., i32, 'runtime']

[..., i32, snippet(a, i32, 'argument')]

return getOne();

[..., i32, 'runtime']

[..., i32, 'runtime']

Here, we can potentially run into issue with getById, calls should be represented by separate snippets

const b = getOne();
return b;

[..., i32, 'runtime']

[..., i32, snippet('getOne()', i32, 'runtime')]

return vec2i(7);

[..., vec2i, 'constant']

[..., vec2i, 'constant']

const a = vec2i(7);
return a;

[..., vec2i, 'this-function']

[..., vec2i, snippet(vec2i(7), vec2i, 'constant')]

const a = vec2i(7);
const b = a;
return b;

[..., iptr<function,vec2i,rw>, 'this-function']

[..., iptr<function,vec2i,rw>, snippet(vec2i(7), vec2i, 'constant')]

Note, how datatype has changed

fn([vec2i])((a) => return a);

[..., vec2i, 'argument']

[..., vec2i, 'argument']

Uninterrupted flow :)

fn([vec2i])((a) => {
  const b = a;
  return b;
})

[..., vec2i, 'argument']

[..., vec2i, snippet(a, vec2i, 'argument')]

Implicit pointer btw, but currently cannot take pointer to te argument. TODO: carefully handle this case

fn([vec2i])((a) => return a.x);

[..., i32, 'argument']

[..., i32, 'argument']

Uninterrupted flow :)

fn([vec2i])((a) => {
  const b = a.x;
  return b;
})

[..., i32, 'runtime']

[..., i32, snippet('a.x', i32, 'argument')]

Comparing to the above flow, origin has changed. Maybe it should remain 'runtime'

return getV();

[..., vec3f, 'runtime']

[..., vec3f, 'runtime']

const b = getV();
return b;

[..., vec3f, 'this-function']

[..., vec3f, snippet('getV()', vec3f, 'runtime')]

return buf.$;

[..., f32, 'runtime']

[..., f32, 'runtime']

Buffer element is naturally ephemeral

const b = buf.$;
return b;

[..., f32, 'runtime']

[..., f32, snippet('buf', f32, 'runtime')]

On the contrary to the function call, we should distribute only
1 reference to buffer access snippet

return buf.$;

[..., vec3f, 'uniform']

[..., vec3f, 'uniform']

Buffer element is NOT naturally ephemeral

const b = buf.$;
return b;

[..., iptr<uniform,vec3f,r>, 'uniform']

[..., iptr<uniform,vec3f,r>, snippet('buf', vec3f, 'uniform')]

return buf.$;

[..., f32, 'runtime']

[..., f32, 'runtime']

const b = buf.$;
return b;

[..., f32, 'runtime']

[..., f32, snippet('buf', f32, 'runtime')]

return buf.$;

[..., vec3f, 'readonly']

[..., vec3f, 'readonly']

const b = buf.$;
return b;

[..., iptr<storage,vec3f,r>, 'readonly']

[..., iptr<storage,vec3f,r>, snippet('buf', vec3f, 'readonly')]

return buf.$;

[..., f32, 'runtime']

[..., f32, 'runtime']

const b = buf.$;
return b;

[..., f32, 'runtime']

[..., f32, snippet('buf', f32, 'runtime')]

return buf.$;

[..., vec3f, 'mutable']

[..., vec3f, 'mutable']

const b = buf.$;
return b;

[..., iptr<storage,vec3f,rw>, 'mutable']

[..., iptr<storage,vec3f,rw>, snippet('buf', vec3f, 'mutable')]

return pv.$;

[..., f32, 'runtime']

[..., f32, 'runtime']

const b = pv.$;
return b;

[..., f32, 'runtime']

[..., f32, snippet('pv', f32, 'runtime')]

return pv.$;

[..., vec3f, 'private']

[..., vec3f, 'private']

const b = pv.$;
return b;

[..., iptr<private,vec3f,rw>, 'private']

[..., iptr<private,vec3f,rw>, snippet('pv', vec3f, 'private')]

return wgv.$;

[..., f32, 'runtime']

[..., f32, 'runtime']

const b = wgv.$;
return b;

[..., f32, 'runtime']

[..., f32, snippet('wgv', f32, 'runtime')]

return wgv.$;

[..., vec3f, 'workgroup']

[..., vec3f, 'workgroup']

const b = wgv.$;
return b;

[..., iptr<workgroup,vec3f,rw>, 'workgroup']

[..., iptr<workgroup,vec3f,rw>, snippet('wgv', vec3f, 'workgroup')]

return layout.$.s;

[..., sampler, 'handle']

[..., sampler, 'handle']

For now, you cannot assign sampler or texture to a variable

return c.$;

[..., u32, 'constant']

[..., u32, 'constant']

const b = c.$;
return b;

[..., u32, 'constant']

[..., u32, snippet('c', u32, 'constant')]

return c.$;

[..., vec3f, 'constant-tgpu-const-ref']

[..., vec3f, 'constant-tgpu-const-ref']

const b = c.$;
return b;

[..., vec3f, 'constant-tgpu-const-ref']

[..., vec3f, snippet('c', vec3f, 'constant-tgpu-const-ref')]

fn([i32])((i) => return arr.$[i]);

[..., f32, 'runtime']

[..., f32, 'runtime']

fn([i32])((i) => {
  const b = arr.$[i];
  return b;
})

[..., f32, 'runtime']

[..., f32, snippet('arr[i]', f32, 'runtime')]

fn([i32])((i) => return arr.$[i]);

[..., vec3f, 'runtime-tgpu-const-ref']

[..., vec3f, 'runtime-tgpu-const-ref']

fn([i32])((i) => {
  const b = arr.$[i];
  return b;
})

[..., vec3f, 'runtime-tgpu-const-ref']

[..., vec3f, snippet('arr[i]', vec3f, 'runtime-tgpu-const-ref')]

return buf.$.count;

[..., u32, 'runtime']

[..., u32, 'runtime']

const b = buf.$.count;
return b;

[..., u32, 'runtime']

[..., u32, snippet('buf.count', u32, 'runtime')]

Access to struct should be distributed as reference to one unique snippet

return buf.$.pos;

[..., vec3f, 'uniform']

[..., vec3f, 'uniform']

const b = buf.$.pos;
return b;

[..., iptr<uniform,vec3f,r>, 'uniform']

[..., iptr<uniform,vec3f,r>, snippet('buf.$.pos', vec3f, 'uniform')]

fn([vec3f])((v) => return v.x);

[..., f32, 'argument']

[..., f32, 'argument']

fn([vec3f])((v) => {
  const b = v.x;
  return b;
})

[..., f32, 'runtime']

[..., f32, snippet('v.x', f32, 'runtime')]

fn([vec3f])((v) => return v.xy);

[..., vec2f, 'runtime']

[..., vec2f, 'runtime']

fn([vec3f])((v) => {
  const b = v.xy;
  return b;
})

[..., vec2f, 'this-function']

[..., vec2f, snippet('v.xy', vec2f, 'runtime')]

const b = d.ref(u32(0));
return b;

[..., ptr<function,u32,rw>, 'function']

[..., ptr<function,u32,rw>, snippet(u32(0), u32, 'constant')]

Not sure about that

const b = d.ref(vec2f());
return b;

[..., ptr<function,vec2f,rw>, 'function']

[..., ptr<function,vec2f,rw>, snippet(vec2f(0), vec2f, 'constant')]

return vec4f(7).xz;

[..., vec2f, 'constant']

[..., vec2f, 'constant']

const b = vec4f(7).xz;
return b;

[..., vec2f, 'this-function']

[..., vec2f, snippet(vec4f(7).xz, vec2f, 'constant')]

return vec4f(buf.$, 1).xw;

[..., vec2f, 'runtime']

[..., vec2f, 'runtime']

const b = vec4f(buf.$, 1).xw;
return b;

[..., vec2f, 'this-function']

[..., vec2f, snippet(vec4f(buf.$, 1), vec2f, 'runtime')]

Constructors perform deep copy :))

const a = Boid();
return a.pos;

[..., vec2f, 'this-function']

[..., vec2f, 'this-function']

Not sure about that because there is nothing to be referenced

const a = Boid();
const b = a.pos;
return b;

[..., iptr<function,vec2f,rw>, 'this-function']

[..., iptr<function,vec2f,rw>, snippet(a.pos, vec2f, 'this-function')]

const a = Boid({ pos: buf.$, ... });
return a.pos;

[..., vec2f, 'this-function']

[..., vec2f, 'this-function']

Again, constructors perform deep copy

const a = Boid({ pos: buf.$, ... });
const b = a.pos;
return b;

[..., iptr<function,vec2f,rw>, 'this-function']

[..., iptr<function,vec2f,rw>, snippet(a.pos, vec2f, 'this-function')]