Function compile

src/compute-engine/compilation/gpu-target.ts:3383–3505

(
    expr: Expression,
    options: CompilationOptions<Expression> = {}
  )

  }

  // A string KEY. Only a dictionary base takes one (and that base has already
  // declined above), so on a positional base it is the wrong index domain
  // outright — named separately from the type-based decline below, which
  // covers a symbol merely DECLARED `string`.
  if (isString(index))
    decline(
      'the index is a string key, and only a dictionary base takes one — a ' +
        'positional shader access indexes by number'
    );

  if (BaseCompiler.isComplexValued(index))
    decline(
      'the index is a complex value, which lowers to a `vec2(re, im)`; the ' +
        'interpreter reads its real part, and a shader has no such reading ' +
        'of a vector in an index position'
    );

  // A CALLER-DECLARED name, whose declared shader type is the only reading of
  // it there is — asked ahead of the type-based readings below, which see the
  // undeclared engine symbol's type.
  const framedIndex = gpuAtFramedIndex(index);
  if (framedIndex !== undefined && 'decline' in framedIndex)
    decline(framedIndex.decline);

  // A literal real index resolves against N at compile time — zero runtime
  // cost, and `0` / out of range / non-integer / non-finite fold straight to
  // the NaN spelling.
  if (isNumber(index)) {
    const j = gpuAtSlot(index.re, n);
    if (j === null) {
      // The fold emits neither operand (the index is a literal, so pure).
      requirePureFold('base');
      return gpuNaN(target);
    }
    if (isLiteralBase) requireLiteralBaseElements([j], 'access');
    return gpuAtElement(base, j, n, compile);
  }

  // A collection-typed index that is NOT a literal list: there is no tier for
  // it (its entries are not readable at compile time). A STRING is excluded:
  // it matches `collection` in the lattice (its elements are its grapheme
  // clusters) but this target has no strings at all, so the honest diagnostic
  // is the "provably not a number" one below, which names the type — the
  // diagnostic a string index has always received.
  if (isSubtype(it, COLLECTION_SHAPE_TYPE) && !isSubtype(it, 'string')) {
    const k = BaseCompiler.aggregateComponentCount(index);
    // A NEGATIVE count is the type builder's encoding of an UNKNOWN extent
    // (`list<number^?>` → `dimensions: [-1]`), not a width — the same reading
    // the base side already takes. Without this it flowed on as a count and
    // described "a collection of -1 runtime-valued entries" in a
    // demand-gated text, when the shape is the PERMANENT no-static-count
    // decline (design § D4).
    if (k === undefined || k < 0)
      decline(
        `the index is a collection (type \`${index.type.toString()}\`) with ` +
          `no statically known length, so there is no static count to emit ` +
          `a result shape against`
      );