Cannot assign readonly statics in static blocks

🔍 Search Terms

"assign readonly static in static block", "assign readonly static in static constructor"

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

static readonly fields should be assignable within static code blocks, similar to how readonly fields are assignable in constructors. I've had a read through various issues, and those around the MR that introduced support for static blocks, but found no mention of dealing with readonly fields.

📃 Motivating Example

I'm making a variation on ringbufferjs, here, this.headerSize = ... shows an error without the //@ts-expect-error

type TypedArray =
  | Float32Array
  | Float64Array
  | Int8Array
  | Int16Array
  | Int32Array
  | BigInt64Array;
type TypedArrayConstructor =
  | Float32ArrayConstructor
  | Float64ArrayConstructor
  | Int8ArrayConstructor
  | Int16ArrayConstructor
  | Int32ArrayConstructor
  | BigInt64ArrayConstructor;

export default class LiveRingBuffer {
  private static readonly headerSize: number;

  static {
    const writePtrWidth = Uint32Array.BYTES_PER_ELEMENT;
    const readPtrWidth = Uint32Array.BYTES_PER_ELEMENT;
    const lapPtrWidth = Uint32Array.BYTES_PER_ELEMENT;
    //@ts-expect-error
    this.headerSize = writePtrWidth + readPtrWidth + lapPtrWidth;
  }

  static getStorageForCapacity(
    capacity: number,
    type: TypedArrayConstructor,
  ): SharedArrayBuffer {
    if (!type.BYTES_PER_ELEMENT) {
      throw TypeError('Pass in a ArrayBuffer subclass');
    }
    const storageWidth = (capacity + 1) * type.BYTES_PER_ELEMENT;
    const alignedHeaderWidth =
      Math.ceil(this.headerSize / type.BYTES_PER_ELEMENT) *
      type.BYTES_PER_ELEMENT;

    const bytes = alignedHeaderWidth + storageWidth;
    return new SharedArrayBuffer(bytes);
  }

  // ...
}

💻 Use Cases

1. What do you want to use this for?
   See "Motivating Example"
2. What shortcomings exist with current approaches?
   Current approach suppresses readonly error; alternative is to remove the readonly keyword, also not ideal since it really is readonly/const
3. What workarounds are you using in the meantime?
   //@ts-expect-error hides the error and emits the desired code.