Function createTarget

src/compute-engine/compilation/gpu-target.ts:3329–3381

(
    options: Partial<CompileTarget<Expression>> = {}
  )

      `the shader builtin \`${callee}\` is declared over scalar and \`vecN\` ` +
        `genTypes; it has no ${hasMatrix ? '`matN`' : 'array'} overload, so ` +
        `the operand shapes (${shapes.map(gpuShapeName).join(', ')}) have no ` +
        `lowering.`
    );
  declineWidths();
  const reshapes = gpuReshapesOperands(code);
  if (reshapes !== undefined)
    decline(
      `the shader lowering \`${code}\` cannot take the non-scalar operand ` +
        `shapes (${shapes.map(gpuShapeName).join(', ')}) — ${reshapes}`
    );
  // The shapes as they REACH the emitted call. A lowering is allowed to widen
  // a scalar operand itself, by writing out the broadcast constructor neither
  // language supplies (`Power` over a `vecN` base and a scalar exponent emits
  // `pow(v, vec3(y))`); the CE operand stays a scalar, but the argument that
  // stands in the call is a vector, so the mixed-genType checks below would
  // otherwise decline valid source. Only an UPGRADE is taken from the emitted
  // argument, and only where the lowering passes its operands through one for
  // one — a source that constructs no vector keeps its CE shape, so nothing
  // here can weaken a check.
  const emitted = shapes.map((s, i) => {
    if (s !== 'scalar' || argCount !== args.length) return s;
    return gpuConstructedVectorWidth(call.operands[i]) ?? s;
  });
  if (widths.size === 1 && emitted.includes('scalar')) {
    const slots = rules.scalarGenTypeSlots.get(callee);
    if (slots === undefined)
      decline(
        `the shader builtin \`${callee}\` requires MATCHING genType ` +
          `arguments, but it is applied to a vec${[...widths][0]} operand and ` +
          `a scalar one; the scalar is not promoted to a vector.`
      );
    // The overload says WHERE a scalar may stand, not merely that one may:
    // `mod(genType, float)` admits it only LAST, `step(float, genType)` only
    // FIRST, `mix(genType, genType, float)` only third. When the lowering
    // passes its operands through ONE FOR ONE the CE operand shapes give the
    // positions exactly — including for an operand with no constructor in its
    // source (a symbol declared `vector<3>`).
    if (argCount === args.length) {
      const bad = emitted.findIndex((s, i) => s === 'scalar' && !slots.has(i));
      if (bad >= 0)
        decline(
          `the shader builtin \`${callee}\` takes a scalar only ` +
            `${gpuSlotNames(slots)}, but here the scalar stands in argument ` +
            `${bad + 1}, where the overload requires the vec${
              [...widths][0]
            } genType; the scalar is not promoted to a vector.`
        );
    }
    // A lowering that does NOT pass its operands through (the variadic
    // `min`/`max` fold) is judged on the emitted call TREE, where each nested
    // call has its own argument positions.
    const misplaced = gpuMisplacedScalarArgument(
      code,
      rules.scalarGenTypeSlots
    );
    if (misplaced !== undefined) decline(misplaced);