Function parseSetComprehension

src/compute-engine/library/collections.ts:2829–2924

* Determine whether the operands of a `Set` expression describe a * set-builder (comprehension) rather than a literal set. * * A `Set` is a comprehension iff it has exactly two operands and the second * operand is an indexing-set form: * * - `["Set", body, ["Element", v, domain, cond?]]` — the

(
  ops: ReadonlyArray<Expression>
)

// ── Property stores: `p.age = 43` ────────────────────────────────────────────
//
// Assignment through a `Field` target is a **store into a mutable object**,
// and it is legal on nothing else. Spec: `docs/TYPE_SYSTEM_ROADMAP.md`
// Appendix B, "Assigning to a property" and "A store writes the evaluated
// value". The two functions below are the canonical-time and evaluate-time
// halves of one decision, and `Assign` (`library/core.ts`) is their only
// caller.
//

/**
 * Does the receiver's own object layout declare this field?
 *
 * This is the question that has to be asked BEFORE the protocol-property
 * route, and it is asked of the STATIC type because the canonical handler has
 * no value in hand. An object's stored fields belong to the object: when a
 * `readwrite` protocol happens to declare a property of the same name, the
 * store still wins.
 *
 * A `true` here means "this is certainly a store, do not refuse it statically",
 * and it earns its place by reading a bare-symbol receiver off its DEFINITION:
 * {@link fieldAssignmentVerdict} canonicalizes the receiver instead, which
 * folds a single-letter target into the library constant of that name (`i`
 * becomes `ImaginaryUnit`) and would report a settled non-object type for a
 * binding that in fact holds an object.
 *
 * Answers `false` whenever the layout cannot be read — an unsettled receiver,
 * a bare `object` annotation (which promises fields without naming them), a
 * union. Those defer to the runtime route, where `objectFieldStore` puts the
 * instance's own layout back in charge.
 *
 * `isObjectFieldStore()` in `boxed-expression/effects-of.ts` resolves a
 * receiver by the same two rules, for a different purpose: labelling the
 * assignment's EFFECT. It deliberately parts company on the union case, where
 * it claims the store rather than declining — an effect label cannot be
 * deferred to evaluation the way this precedence decision can, and the store
 * does happen. Keep the receiver resolution in step; that one arm is meant to
 * differ.
 */
export function objectLayoutOwnsField(
  ce: ComputeEngine,
  lhs: Expression
): boolean {
  if (!isFunction(lhs, 'Field')) return false;
  if (!isString(lhs.ops[1])) return false;
  const name = lhs.ops[1].string;
  const base = lhs.ops[0];
  if (base === undefined) return false;

  // A bare-symbol receiver is read off its DEFINITION, never by canonicalizing
  // it: canonicalizing a single-letter target folds it into the constant of
  // that name (`i` becomes `ImaginaryUnit`), which is why `Assign` keeps its
  // left operand raw at all.
  const rootName = sym(base);
  if (rootName !== undefined) {
    const def = ce.lookupDefinition(rootName);
    const t =
      def !== undefined && isValueDef(def) ? def.value.type.type : undefined;
    return (
      t !== undefined && objectLayoutOfType(t)?.elements[name] !== undefined