fix: Enable erasableSyntaxOnly and verbatimModuleSyntax TypeScript options (#2332)

Author: iwoplaza

packages/typegpu-gl/src/tgpuRootWebGL.ts

@@ -6,7 +6,7 @@
  * Compute operations, storage buffers, textures, etc. throw WebGLFallbackUnsupportedError.
  */
 
-import tgpu, { d, ShaderGenerator, TgpuFragmentFn, TgpuVertexFn } from 'typegpu';
+import tgpu, { d, ShaderGenerator, type TgpuFragmentFn, type TgpuVertexFn } from 'typegpu';
 import glslGenerator, { translateWgslTypeToGlsl } from './glslGenerator.ts';
 
 // ----------

packages/typegpu-sort/src/scan/prefixScan.ts

@@ -27,12 +27,19 @@ export class PrefixScanComputer {
   #scanPipeline?: TgpuComputePipeline;
   #reducePipeline?: TgpuComputePipeline;
   #opPipeline?: TgpuComputePipeline;
+  #root: TgpuRoot;
+  #operation: BinaryOp['operation'];
+  #identityElement: BinaryOp['identityElement'];
 
   constructor(
-    private root: TgpuRoot,
-    private operation: BinaryOp['operation'],
-    private identityElement: BinaryOp['identityElement'],
-  ) {}
+    root: TgpuRoot,
+    operation: BinaryOp['operation'],
+    identityElement: BinaryOp['identityElement'],
+  ) {
+    this.#root = root;
+    this.#operation = operation;
+    this.#identityElement = identityElement;
+  }
 
   private getScanPipeline(onlyGreatestElement: boolean): TgpuComputePipeline {
     const cached = onlyGreatestElement ? this.#reducePipeline : this.#scanPipeline;
@@ -41,9 +48,9 @@ export class PrefixScanComputer {
       return cached;
     }
 
-    const pipeline = this.root
-      .with(operatorSlot, this.operation)
-      .with(identitySlot, this.identityElement)
+    const pipeline = this.#root
+      .with(operatorSlot, this.#operation)
+      .with(identitySlot, this.#identityElement)
       .with(onlyGreatestElementSlot, onlyGreatestElement)
       .createComputePipeline({
         compute: computeBlock,
@@ -59,14 +66,14 @@ export class PrefixScanComputer {
   }
 
   private get opPipeline(): TgpuComputePipeline {
-    this.#opPipeline ??= this.root.with(operatorSlot, this.operation).createComputePipeline({
+    this.#opPipeline ??= this.#root.with(operatorSlot, this.#operation).createComputePipeline({
       compute: uniformOp,
     });
     return this.#opPipeline;
   }
 
   private getScratchBuffer(size: number): TgpuBuffer<d.WgslArray<d.F32>> & StorageFlag {
-    return this.root.createBuffer(d.arrayOf(d.f32, size)).$usage('storage');
+    return this.#root.createBuffer(d.arrayOf(d.f32, size)).$usage('storage');
   }
 
   private recursiveScan(
@@ -82,7 +89,7 @@ export class PrefixScanComputer {
     // Base case: single workgroup
     if (numWorkgroups === 1) {
       const finalSums = this.getScratchBuffer(1);
-      const bg = this.root.createBindGroup(scanLayout, {
+      const bg = this.#root.createBindGroup(scanLayout, {
         input: buffer,
         sums: finalSums,
       });
@@ -102,7 +109,7 @@ export class PrefixScanComputer {
     // Recursive case:
     let sumsBuffer = this.getScratchBuffer(numWorkgroups);
 
-    const scanBg = this.root.createBindGroup(scanLayout, {
+    const scanBg = this.#root.createBindGroup(scanLayout, {
       input: buffer,
       sums: sumsBuffer,
     });
@@ -128,7 +135,7 @@ export class PrefixScanComputer {
       return sumsBuffer;
     }
 
-    const opBg = this.root.createBindGroup(uniformOpLayout, {
+    const opBg = this.#root.createBindGroup(uniformOpLayout, {
       input: buffer,
       sums: sumsBuffer,
     });

packages/typegpu/src/core/buffer/buffer.ts

@@ -189,17 +189,19 @@ export function isUsableAsIndex<T extends TgpuBuffer<BaseData>>(
 const endianness = getSystemEndianness();
 
 class TgpuBufferImpl<TData extends BaseData> implements TgpuBuffer<TData> {
-  public readonly [$internal] = true;
-  public readonly resourceType = 'buffer';
-  public flags: GPUBufferUsageFlags = GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
+  readonly [$internal] = true;
+  readonly resourceType = 'buffer';
+  flags: GPUBufferUsageFlags = GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
+  readonly dataType: TData;
 
   readonly #device: GPUDevice;
-  private _buffer: GPUBuffer | null = null;
-  private _ownBuffer: boolean;
-  private _destroyed = false;
-  private _hostBuffer: ArrayBuffer | undefined;
-  private _mappedRange: ArrayBuffer | undefined;
-  private _initialCallback: BufferInitCallback<TData> | undefined;
+  #buffer: GPUBuffer | null = null;
+  #ownBuffer: boolean;
+  #destroyed = false;
+  #hostBuffer: ArrayBuffer | undefined;
+  #mappedRange: ArrayBuffer | undefined;
+  #initialCallback: BufferInitCallback<TData> | undefined;
+  readonly #disallowedUsages: UsageLiteral[] | undefined;
 
   readonly initial: InferInput<TData> | undefined;
 
@@ -211,52 +213,54 @@ class TgpuBufferImpl<TData extends BaseData> implements TgpuBuffer<TData> {
 
   constructor(
     root: ExperimentalTgpuRoot,
-    public readonly dataType: TData,
+    dataType: TData,
     initialOrBuffer?: BufferInitialData<TData> | GPUBuffer,
-    private readonly _disallowedUsages?: UsageLiteral[],
+    disallowedUsages?: UsageLiteral[],
   ) {
+    this.dataType = dataType;
+    this.#disallowedUsages = disallowedUsages;
     this.#device = root.device;
     if (isGPUBuffer(initialOrBuffer)) {
-      this._ownBuffer = false;
-      this._buffer = initialOrBuffer;
+      this.#ownBuffer = false;
+      this.#buffer = initialOrBuffer;
     } else {
-      this._ownBuffer = true;
+      this.#ownBuffer = true;
       if (typeof initialOrBuffer === 'function') {
-        this._initialCallback = initialOrBuffer as BufferInitCallback<TData>;
+        this.#initialCallback = initialOrBuffer as BufferInitCallback<TData>;
       } else {
         this.initial = initialOrBuffer;
       }
     }
   }
 
   get buffer() {
-    if (this._destroyed) {
+    if (this.#destroyed) {
       throw new Error('This buffer has been destroyed');
     }
 
-    if (!this._buffer) {
-      this._buffer = this.#device.createBuffer({
+    if (!this.#buffer) {
+      this.#buffer = this.#device.createBuffer({
         size: sizeOf(this.dataType),
         usage: this.flags,
-        mappedAtCreation: !!this.initial || !!this._initialCallback,
+        mappedAtCreation: !!this.initial || !!this.#initialCallback,
         label: getName(this) ?? '<unnamed>',
       });
 
-      if (this.initial || this._initialCallback) {
-        if (this._initialCallback) {
-          this._initialCallback(this);
+      if (this.initial || this.#initialCallback) {
+        if (this.#initialCallback) {
+          this.#initialCallback(this);
         } else if (this.initial) {
           this.#writeToTarget(this.#getMappedRange(), this.initial);
         }
         this.#unmapBuffer();
       }
     }
 
-    return this._buffer;
+    return this.#buffer;
   }
 
   get destroyed() {
-    return this._destroyed;
+    return this.#destroyed;
   }
 
   get arrayBuffer(): ArrayBuffer {
@@ -265,35 +269,35 @@ class TgpuBufferImpl<TData extends BaseData> implements TgpuBuffer<TData> {
       return this.#getMappedRange();
     }
 
-    if (!this._hostBuffer) {
-      this._hostBuffer = new ArrayBuffer(sizeOf(this.dataType));
+    if (!this.#hostBuffer) {
+      this.#hostBuffer = new ArrayBuffer(sizeOf(this.dataType));
     }
 
-    return this._hostBuffer;
+    return this.#hostBuffer;
   }
 
   #getMappedRange(): ArrayBuffer {
-    if (!this._buffer || this._buffer.mapState !== 'mapped') {
+    if (!this.#buffer || this.#buffer.mapState !== 'mapped') {
       throw new Error('Buffer is not mapped.');
     }
 
-    this._mappedRange ??= this._buffer.getMappedRange();
-    return this._mappedRange;
+    this.#mappedRange ??= this.#buffer.getMappedRange();
+    return this.#mappedRange;
   }
 
   #unmapBuffer(): void {
-    if (!this._buffer || this._buffer.mapState !== 'mapped') {
+    if (!this.#buffer || this.#buffer.mapState !== 'mapped') {
       return;
     }
 
-    this._mappedRange = undefined;
-    this._buffer.unmap();
+    this.#mappedRange = undefined;
+    this.#buffer.unmap();
   }
 
   $name(label: string) {
     setName(this, label);
-    if (this._buffer) {
-      this._buffer.label = label;
+    if (this.#buffer) {
+      this.#buffer.label = label;
     }
     return this;
   }
@@ -302,7 +306,7 @@ class TgpuBufferImpl<TData extends BaseData> implements TgpuBuffer<TData> {
     ...usages: T
   ): this & UnionToIntersection<LiteralToUsageType<T[number]>> {
     for (const usage of usages) {
-      if (this._disallowedUsages?.includes(usage)) {
+      if (this.#disallowedUsages?.includes(usage)) {
         throw new Error(`Buffer of type ${this.dataType.type} cannot be used as ${usage}`);
       }
 
@@ -321,7 +325,7 @@ class TgpuBufferImpl<TData extends BaseData> implements TgpuBuffer<TData> {
   }
 
   $addFlags(flags: GPUBufferUsageFlags) {
-    if (!this._ownBuffer) {
+    if (!this.#ownBuffer) {
       throw new Error('Cannot add flags to a buffer that is not managed by TypeGPU.');
     }
 
@@ -426,16 +430,16 @@ class TgpuBufferImpl<TData extends BaseData> implements TgpuBuffer<TData> {
       return;
     }
 
-    if (!this._hostBuffer) {
-      this._hostBuffer = new ArrayBuffer(bufferSize);
+    if (!this.#hostBuffer) {
+      this.#hostBuffer = new ArrayBuffer(bufferSize);
     }
 
-    // If the caller already wrote directly into _hostBuffer via
+    // If the caller already wrote directly into #hostBuffer via
     // arrayBuffer, skip the redundant copy, the data is already in place.
-    if (!(data instanceof ArrayBuffer && data === this._hostBuffer)) {
-      this.#writeToTarget(this._hostBuffer, data, options);
+    if (!(data instanceof ArrayBuffer && data === this.#hostBuffer)) {
+      this.#writeToTarget(this.#hostBuffer, data, options);
     }
-    this.#device.queue.writeBuffer(gpuBuffer, startOffset, this._hostBuffer, startOffset, size);
+    this.#device.queue.writeBuffer(gpuBuffer, startOffset, this.#hostBuffer, startOffset, size);
   }
 
   public writePartial(data: InferPartial<TData>): void {
@@ -527,13 +531,13 @@ class TgpuBufferImpl<TData extends BaseData> implements TgpuBuffer<TData> {
   }
 
   destroy() {
-    if (this._destroyed) {
+    if (this.#destroyed) {
       return;
     }
-    this._destroyed = true;
-    this._mappedRange = undefined;
-    if (this._ownBuffer) {
-      this._buffer?.destroy();
+    this.#destroyed = true;
+    this.#mappedRange = undefined;
+    if (this.#ownBuffer) {
+      this.#buffer?.destroy();
     }
   }
 

packages/typegpu/src/core/buffer/bufferShorthand.ts

@@ -86,13 +86,18 @@ export class TgpuBufferShorthandImpl<
 > implements SelfResolvable {
   readonly [$internal] = true;
   readonly [$getNameForward]: object;
+  readonly resourceType: TType;
+  readonly buffer: TgpuBuffer<TData> &
+    (TType extends 'mutable' | 'readonly' ? StorageFlag : UniformFlag);
+
   readonly #usage: TgpuBufferUsage<TData, TType>;
 
   constructor(
-    public readonly resourceType: TType,
-    public readonly buffer: TgpuBuffer<TData> &
-      (TType extends 'mutable' | 'readonly' ? StorageFlag : UniformFlag),
+    resourceType: TType,
+    buffer: TgpuBuffer<TData> & (TType extends 'mutable' | 'readonly' ? StorageFlag : UniformFlag),
   ) {
+    this.resourceType = resourceType;
+    this.buffer = buffer;
     this[$getNameForward] = buffer;
     // oxlint-disable-next-line typescript/no-explicit-any -- too complex a type
     this.#usage = (this.buffer as any).as(this.resourceType);

packages/typegpu/src/core/buffer/bufferUsage.ts

@@ -97,14 +97,16 @@ class TgpuFixedBufferImpl<TData extends BaseData, TUsage extends BindableBufferU
 {
   /** Type-token, not available at runtime */
   declare readonly [$repr]: Infer<TData>;
+
   readonly resourceType = 'buffer-usage' as const;
+  readonly usage: TUsage;
+  readonly buffer: TgpuBuffer<TData>;
   readonly [$internal]: { readonly dataType: TData };
   readonly [$getNameForward]: TgpuBuffer<TData>;
 
-  constructor(
-    public readonly usage: TUsage,
-    public readonly buffer: TgpuBuffer<TData>,
-  ) {
+  constructor(usage: TUsage, buffer: TgpuBuffer<TData>) {
+    this.usage = usage;
+    this.buffer = buffer;
     this[$internal] = { dataType: buffer.dataType };
     this[$getNameForward] = buffer;
   }
@@ -222,16 +224,18 @@ export class TgpuLaidOutBufferImpl<TData extends BaseData, TUsage extends Bindab
 {
   /** Type-token, not available at runtime */
   declare readonly [$repr]: Infer<TData>;
+
   readonly [$internal]: { readonly dataType: TData };
   readonly resourceType = 'buffer-usage' as const;
+  readonly usage: TUsage;
+  readonly dataType: TData;
+
   readonly #membership: LayoutMembership;
 
-  constructor(
-    public readonly usage: TUsage,
-    public readonly dataType: TData,
-    membership: LayoutMembership,
-  ) {
+  constructor(usage: TUsage, dataType: TData, membership: LayoutMembership) {
     this[$internal] = { dataType };
+    this.usage = usage;
+    this.dataType = dataType;
     this.#membership = membership;
     setName(this, membership.key);
   }

packages/typegpu/src/core/constant/tgpuConstant.ts

@@ -94,13 +94,13 @@ function deepFreeze<T extends object>(object: T): T {
 class TgpuConstImpl<TDataType extends BaseData> implements TgpuConst<TDataType>, SelfResolvable {
   readonly [$internal] = {};
   readonly resourceType: 'const';
+  readonly dataType: TDataType;
+
   readonly #value: DeepReadonly<InferGPU<TDataType>>;
 
-  constructor(
-    public readonly dataType: TDataType,
-    value: InferGPU<TDataType>,
-  ) {
+  constructor(dataType: TDataType, value: InferGPU<TDataType>) {
     this.resourceType = 'const';
+    this.dataType = dataType;
     this.#value =
       value && typeof value === 'object'
         ? (deepFreeze(value) as DeepReadonly<InferGPU<TDataType>>)