Why do we need to special-case arrays?

That was the behaviour of builder.js:

arg = Array.isArray(field.default) ? [] : field.default;

I will check if we have weird field.default.

I think we had that check to avoid sharing the same [] reference every time, but since it's now a new [] value for every call it's always a different one.

To generate slightly smaller code, we could modify validateNode like this:

function validateNode<N extends t.Node>(node: N): N {
  // todo: because keys not in BUILDER_KEYS are not validated - this actually allows invalid nodes in some cases
  const keys = BUILDER_KEYS[node.type];
  for (const key of keys) {
    validate(node, key, node[key]);
  }
  return node;
}

and then do

export function arrayExpression(
     elements: Array<null | t.Expression | t.SpreadElement> = [],
) {
  return validateNode<t.ArrayExpression>({
    type: "ArrayExpression",
    elements,
  });
}

The return type annotation is preserved because we skip validateNode for nodes with empty builder keys.

Nit: since these just come from local param names, can't we make it always match?

Most of the argument name match the AST field name. The exceptions are non-valid binding identifier names, such as CallExpression's arguments and ClassMethod's static.

Ahhh