Is there a better way to visit attributes in AST?

[aleksanderkatan]

I'm traversing the AST and I need to know the kind of an attribute and the types and values of its parameters. The only way to do so that I found is to call attributeToString function and regex over it. Also, the function parses numbers to string literals, like so: @location('0'), which I think may be a bug.

[mighdoll]

I can believe that you'd like more info! But what exactly are you hoping to find for which attributes? And when do you want it?

Seems like the general thing you might want is a way to evaluate the const expression inside @location(const_expression) to a value, and maybe a type like u32 or i32?

When do you want to extract this info? Typically it'd be statically defined in the text either as a simple number, or as a const expression I suppose.

But now I'm wondering what happens if the const expression uses a runtime injected constant. The wesl linkers currently allow runtime injection of constants (which are then addressable in wesl as import constants::fragLoc;

e.g. I suppose you could write:

import constants::fragLoc;

@fragment
fn frag() -> @location(fragLoc) vec4f { }

I suspect there's something we could do that would handle most of what you want, and there may be some new wrinkles to explore too... injected constants, maybe @if conditions..

[iwoplaza]

Hmm, let's explore this a bit. Currently we're able to import structs as named exports from a shader file, like so:

// shader.wgsl
struct Boid {
  position: vec3f,
  velocity: vec3f,
}

// main.ts
import { Boid } from './shader.wgsl?typegpu';

However, if the definitions were dependent on runtime constants, we would have to provide them before getting reified references back:

// shader.wgsl
import constants::boids;

@if(boids)
struct Boid {
  position: vec3f,
  velocity: vec3f,
}

// main.ts
import shaderReflection from './shader.wgsl?typegpu';

const { Boid } = shaderReflection({
  boids: true,
});

The dynamically generated code of ./shader.wgsl?typegpu could be:

import * as d from 'typegpu';

const Boid = d.struct({
  position: d.vec3f,
  velocity: d.vec3f,
});

interface Constants {
  boids: boolean;
};

function reflection<T extends Constants>(constants: T):
  T['boids'] extends true
    ? { boids: typeof Boid }
    : { boids: undefined } {
  return {
    Boid: constants.boids ? Boid : undefined,
  };
}

export default reflection;

We can also handle more complex cases, like using constants inside of struct definitions, but lets omit that for now.

Solutions

I see a couple possible solutions we could try out:

1. Export static definitions (those independent of runtime-constants) as named exports, as those are going to be a majority, and house the rest in the default "reflection" export.
2. Export everything always as the default export.

The latter is simpler to implement and maintain, but also sours the DX for most common use-cases. What do we think? 🤔

[mighdoll]

good discussion! I'll make a new issue for this discussion about reflecting to types so we'll be able to find it later more easily..