I'm not sure how to answer that. What's "slow" is that I'm trying to emulate a SharedArray with fields named "length", "0", "1", etc. as well as attach a few extra fields that we normally stash on a NodeArray, which looks something like this:

interface NodeArray<T extends Node> extends Array<T> {
  pos: number;
  end: number;
  hasTrailingComma: boolean;
  transformFlags: TransformFlags; // number
}

If you're asking about other fields, the most frequently hit fields on our AST are pos, end, kind, id, transformFlags, and parent:

interface Node {
  pos: number;
  end: number;
  kind: SyntaxKind; // number
  transformFlags: TransformFlags; // number
  id: number | undefined;
  parent: Node | undefined;
}

Yes. I have two choices for a shared struct implementation of a NodeArray:

1. I use a Shared Struct with a small set of string-named fields (like pos/end), as well a length and a number of indexed fields with no holes. This would emulate NodeArray except for functionality from array prototype as I can just use length and indices instead. This provides enough overlap between NodeArray and SharedNodeArray that I don't need to special case every single function that works with NodeArray.

2. I use a Shared Struct with the same set of string-named fields as well as an items field that holds a SharedArray. In this case, I need to add branching cases in every function that works with NodeArray.