Remove codegenCapacityEstimator methods from all concrete type classes

Co-authored-by: streamich <[email protected]>

Author: Copilot

src/type/classes/AnyType.ts

@@ -76,29 +76,6 @@ export class AnyType extends AbstractType<schema.AnySchema> {
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    const codegen = ctx.codegen;
-    codegen.link('Value');
-    const r = codegen.var(value.use());
-    codegen.if(
-      `${r} instanceof Value`,
-      () => {
-        codegen.if(
-          `${r}.type`,
-          () => {
-            ctx.codegen.js(`size += ${r}.type.capacityEstimator()(${r}.data);`);
-          },
-          () => {
-            ctx.codegen.js(`size += maxEncodingCapacity(${r}.data);`);
-          },
-        );
-      },
-      () => {
-        ctx.codegen.js(`size += maxEncodingCapacity(${r});`);
-      },
-    );
-  }
-
   public toTypeScriptAst(): ts.TsType {
     return {node: 'AnyKeyword'};
   }

src/type/classes/ArrayType.ts

@@ -152,27 +152,6 @@ export class ArrayType<T extends Type> extends AbstractType<schema.ArraySchema<S
     );
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    const codegen = ctx.codegen;
-    ctx.inc(MaxEncodingOverhead.Array);
-    const rLen = codegen.var(`${value.use()}.length`);
-    const type = this.type;
-    codegen.js(`size += ${MaxEncodingOverhead.ArrayElement} * ${rLen}`);
-    const fn = type.compileCapacityEstimator({
-      system: ctx.options.system,
-      name: ctx.options.name,
-    });
-    const isConstantSizeType = type instanceof ConstType || type instanceof BooleanType || type instanceof NumberType;
-    if (isConstantSizeType) {
-      codegen.js(`size += ${rLen} * ${fn(null)};`);
-    } else {
-      const r = codegen.var(value.use());
-      const rFn = codegen.linkDependency(fn);
-      const ri = codegen.getRegister();
-      codegen.js(`for(var ${ri} = ${rLen}; ${ri}-- !== 0;) size += ${rFn}(${r}[${ri}]);`);
-    }
-  }
-
   public toTypeScriptAst(): ts.TsArrayType {
     return {
       node: 'ArrayType',

src/type/classes/BinaryType.ts

@@ -115,11 +115,6 @@ export class BinaryType<T extends Type> extends AbstractType<schema.BinarySchema
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    ctx.inc(MaxEncodingOverhead.Binary);
-    ctx.codegen.js(`size += ${MaxEncodingOverhead.BinaryLengthMultiplier} * ${value.use()}.length;`);
-  }
-
   public toTypeScriptAst(): ts.TsGenericTypeAnnotation {
     return {
       node: 'GenericTypeAnnotation',

src/type/classes/BooleanType.ts

@@ -56,10 +56,6 @@ export class BooleanType extends AbstractType<schema.BooleanSchema> {
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    ctx.inc(MaxEncodingOverhead.Boolean);
-  }
-
   public toTypeScriptAst(): ts.TsBooleanKeyword {
     return {node: 'BooleanKeyword'};
   }

src/type/classes/ConstType.ts

@@ -75,10 +75,6 @@ export class ConstType<V = any> extends AbstractType<schema.ConstSchema<V>> {
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    ctx.inc(maxEncodingCapacity(this.value()));
-  }
-
   public toTypeScriptAst() {
     const value = this.schema.value;
     if (value === null) {

src/type/classes/MapType.ts

@@ -141,30 +141,6 @@ export class MapType<T extends Type> extends AbstractType<schema.MapSchema<Schem
     ctx.blob(objEndBlob);
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    const codegen = ctx.codegen;
-    ctx.inc(MaxEncodingOverhead.Object);
-    const r = codegen.var(value.use());
-    const rKeys = codegen.var(`Object.keys(${r})`);
-    const rKey = codegen.var();
-    const rLen = codegen.var(`${rKeys}.length`);
-    codegen.js(`size += ${MaxEncodingOverhead.ObjectElement} * ${rLen}`);
-    const type = this.type;
-    const fn = type.compileCapacityEstimator({
-      system: ctx.options.system,
-      name: ctx.options.name,
-    });
-    const rFn = codegen.linkDependency(fn);
-    const ri = codegen.var('0');
-    codegen.js(`for (; ${ri} < ${rLen}; ${ri}++) {`);
-    codegen.js(`${rKey} = ${rKeys}[${ri}];`);
-    codegen.js(
-      `size += ${MaxEncodingOverhead.String} + ${MaxEncodingOverhead.StringLengthMultiplier} * ${rKey}.length;`,
-    );
-    codegen.js(`size += ${rFn}(${r}[${rKey}]);`);
-    codegen.js(`}`);
-  }
-
   public toTypeScriptAst(): ts.TsTypeReference {
     const node: ts.TsTypeReference = {
       node: 'TypeReference',

src/type/classes/NumberType.ts

@@ -152,10 +152,6 @@ export class NumberType extends AbstractType<schema.NumberSchema> {
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    ctx.inc(MaxEncodingOverhead.Number);
-  }
-
   public toTypeScriptAst(): ts.TsNumberKeyword {
     return {node: 'NumberKeyword'};
   }

src/type/classes/ObjectType.ts

@@ -480,28 +480,6 @@ if (${rLength}) {
     }
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    const codegen = ctx.codegen;
-    const r = codegen.var(value.use());
-    const encodeUnknownFields = !!this.schema.encodeUnknownFields;
-    if (encodeUnknownFields) {
-      codegen.js(`size += maxEncodingCapacity(${r});`);
-      return;
-    }
-    const fields = this.fields;
-    const overhead = MaxEncodingOverhead.Object + fields.length * MaxEncodingOverhead.ObjectElement;
-    ctx.inc(overhead);
-    for (const field of fields) {
-      ctx.inc(maxEncodingCapacity(field.key));
-      const accessor = normalizeAccessor(field.key);
-      const isOptional = field instanceof ObjectOptionalFieldType;
-      const block = () => field.value.codegenCapacityEstimator(ctx, new JsExpression(() => `${r}${accessor}`));
-      if (isOptional) {
-        codegen.if(`${r}${accessor} !== undefined`, block);
-      } else block();
-    }
-  }
-
   public toTypeScriptAst(): ts.TsTypeLiteral {
     const node: ts.TsTypeLiteral = {
       node: 'TypeLiteral',

src/type/classes/OrType.ts

@@ -138,22 +138,6 @@ export class OrType<T extends Type[]> extends AbstractType<schema.OrSchema<{[K i
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    const codegen = ctx.codegen;
-    const discriminator = this.discriminator();
-    const d = codegen.linkDependency(discriminator);
-    const types = this.types;
-    codegen.switch(
-      `${d}(${value.use()})`,
-      types.map((type, index) => [
-        index,
-        () => {
-          type.codegenCapacityEstimator(ctx, value);
-        },
-      ]),
-    );
-  }
-
   public toTypeScriptAst(): ts.TsUnionType {
     const node: ts.TsUnionType = {
       node: 'UnionType',

src/type/classes/RefType.ts

@@ -118,14 +118,6 @@ export class RefType<T extends Type> extends AbstractType<schema.RefSchema<Schem
     this.codegenBinaryEncoder(ctx, value);
   }
 
-  public codegenCapacityEstimator(ctx: CapacityEstimatorCodegenContext, value: JsExpression): void {
-    const system = ctx.options.system || this.system;
-    if (!system) throw new Error('NO_SYSTEM');
-    const estimator = system.resolve(this.schema.ref).type.capacityEstimator();
-    const d = ctx.codegen.linkDependency(estimator);
-    ctx.codegen.js(`size += ${d}(${value.use()});`);
-  }
-
   public toTypeScriptAst(): ts.TsGenericTypeAnnotation {
     return {
       node: 'GenericTypeAnnotation',