chore(jsii-reflect): use Maps instead of Records (#3671)

Instead of using objects as maps, use actual `Map` as this has better
performance characteristics (results in fewer shadow classes being
generated, and is friendlier with the optimizer).

Author: RomainMuller

packages/jsii-reflect/lib/assembly.ts

@@ -10,9 +10,9 @@ import { Type } from './type';
 import { TypeSystem } from './type-system';
 
 export class Assembly extends ModuleLike {
-  private _typeCache?: { [fqn: string]: Type };
-  private _submoduleCache?: { [fqn: string]: Submodule };
-  private _dependencyCache?: { [name: string]: Dependency };
+  private _typeCache?: Map<string, Type>;
+  private _submoduleCache?: Map<string, Submodule>;
+  private _dependencyCache?: Map<string, Dependency>;
 
   public constructor(system: TypeSystem, public readonly spec: jsii.Assembly) {
     super(system);
@@ -124,13 +124,11 @@ export class Assembly extends ModuleLike {
    * Dependencies on other assemblies (with semver), the key is the JSII assembly name.
    */
   public get dependencies(): readonly Dependency[] {
-    return Object.keys(this._dependencies).map(
-      (name) => this._dependencies[name],
-    );
+    return Array.from(this._dependencies.values());
   }
 
   public findDependency(name: string) {
-    const dep = this._dependencies[name];
+    const dep = this._dependencies.get(name);
     if (!dep) {
       throw new Error(`Dependency ${name} not found for assembly ${this.name}`);
     }
@@ -156,7 +154,7 @@ export class Assembly extends ModuleLike {
    */
   public get submodules(): readonly Submodule[] {
     const { submodules } = this._analyzeTypes();
-    return Object.entries(submodules)
+    return Array.from(submodules.entries())
       .filter(([name, _]) => name.split('.').length === 2)
       .map(([_, submodule]) => submodule);
   }
@@ -166,14 +164,14 @@ export class Assembly extends ModuleLike {
    */
   public get allSubmodules(): readonly Submodule[] {
     const { submodules } = this._analyzeTypes();
-    return Object.values(submodules);
+    return Array.from(submodules.values());
   }
 
   /**
    * All types, even those in submodules and nested submodules.
    */
   public get types(): readonly Type[] {
-    return Object.values(this.typeMap);
+    return Array.from(this.typeMap.values());
   }
 
   /**
@@ -201,26 +199,25 @@ export class Assembly extends ModuleLike {
     jsii.validateAssembly(this.spec);
   }
 
-  protected get submoduleMap(): Readonly<Record<string, Submodule>> {
+  protected get submoduleMap(): ReadonlyMap<string, Submodule> {
     return this._analyzeTypes().submodules;
   }
 
   /**
    * All types in the root of the assembly
    */
-  protected get typeMap(): Readonly<Record<string, Type>> {
+  protected get typeMap(): ReadonlyMap<string, Type> {
     return this._analyzeTypes().types;
   }
 
   private get _dependencies() {
     if (!this._dependencyCache) {
-      this._dependencyCache = {};
+      this._dependencyCache = new Map();
       if (this.spec.dependencies) {
         for (const name of Object.keys(this.spec.dependencies)) {
-          this._dependencyCache[name] = new Dependency(
-            this.system,
+          this._dependencyCache.set(
             name,
-            this.spec.dependencies[name],
+            new Dependency(this.system, name, this.spec.dependencies[name]),
           );
         }
       }
@@ -231,7 +228,7 @@ export class Assembly extends ModuleLike {
 
   private _analyzeTypes() {
     if (!this._typeCache || !this._submoduleCache) {
-      this._typeCache = {};
+      this._typeCache = new Map();
 
       const submoduleBuilders = this.discoverSubmodules();
 
@@ -264,9 +261,9 @@ export class Assembly extends ModuleLike {
 
         if (submodule != null) {
           const moduleName = `${this.spec.name}.${submodule}`;
-          submoduleBuilders[moduleName].addType(type);
+          submoduleBuilders.get(moduleName)!.addType(type);
         } else {
-          this._typeCache[fqn] = type;
+          this._typeCache.set(fqn, type);
         }
       }
 
@@ -279,18 +276,16 @@ export class Assembly extends ModuleLike {
    * Return a builder for all submodules in this assembly (so that we can
    * add types into the objects).
    */
-  private discoverSubmodules(): Record<string, SubmoduleBuilder> {
+  private discoverSubmodules(): Map<string, SubmoduleBuilder> {
     const system = this.system;
 
-    const ret: Record<string, SubmoduleBuilder> = {};
+    const ret = new Map<string, SubmoduleBuilder>();
     for (const [submoduleName, submoduleSpec] of Object.entries(
       this.spec.submodules ?? {},
     )) {
-      ret[submoduleName] = new SubmoduleBuilder(
-        system,
-        submoduleSpec,
+      ret.set(
         submoduleName,
-        ret,
+        new SubmoduleBuilder(system, submoduleSpec, submoduleName, ret),
       );
     }
     return ret;
@@ -306,15 +301,15 @@ export class Assembly extends ModuleLike {
  * to translate
  */
 class SubmoduleBuilder {
-  private readonly types: Record<string, Type> = {};
+  private readonly types = new Map<string, Type>();
 
   private _built?: Submodule;
 
   public constructor(
     private readonly system: TypeSystem,
     private readonly spec: jsii.Submodule,
     private readonly fullName: string,
-    private readonly allModuleBuilders: Record<string, SubmoduleBuilder>,
+    private readonly allModuleBuilders: Map<string, SubmoduleBuilder>,
   ) {}
 
   /**
@@ -344,27 +339,27 @@ class SubmoduleBuilder {
    * Return all the builders from the map that are nested underneath ourselves.
    */
   private findSubmoduleBuilders() {
-    const ret: Record<string, SubmoduleBuilder> = {};
-    for (const [k, child] of Object.entries(this.allModuleBuilders)) {
+    const ret = new Map<string, SubmoduleBuilder>();
+    for (const [k, child] of this.allModuleBuilders) {
       if (child.isChildOf(this)) {
-        ret[k] = child;
+        ret.set(k, child);
       }
     }
     return ret;
   }
 
   public addType(type: Type) {
-    this.types[type.fqn] = type;
+    this.types.set(type.fqn, type);
   }
 }
 
 function mapValues<A, B>(
-  xs: Record<string, A>,
+  xs: ReadonlyMap<string, A>,
   fn: (x: A) => B,
-): Record<string, B> {
-  const ret: Record<string, B> = {};
-  for (const [k, v] of Object.entries(xs)) {
-    ret[k] = fn(v);
+): Map<string, B> {
+  const ret = new Map<string, B>();
+  for (const [k, v] of xs) {
+    ret.set(k, fn(v));
   }
   return ret;
 }

packages/jsii-reflect/lib/class.ts

@@ -7,7 +7,6 @@ import { Method } from './method';
 import { Property } from './property';
 import { ReferenceType } from './reference-type';
 import { TypeSystem } from './type-system';
-import { indexBy } from './util';
 
 export class ClassType extends ReferenceType {
   public constructor(
@@ -76,15 +75,15 @@ export class ClassType extends ReferenceType {
    * @param inherited include all properties inherited from base classes (default: false)
    */
   public getProperties(inherited = false): { [name: string]: Property } {
-    return this._getProperties(inherited, this);
+    return Object.fromEntries(this._getProperties(inherited, this));
   }
 
   /**
    * List all methods in this class.
    * @param inherited include all methods inherited from base classes (default: false)
    */
   public getMethods(inherited = false): { [name: string]: Method } {
-    return this._getMethods(inherited, this);
+    return Object.fromEntries(this._getMethods(inherited, this));
   }
 
   /**
@@ -118,39 +117,35 @@ export class ClassType extends ReferenceType {
   private _getProperties(
     inherited: boolean,
     parentType: ReferenceType,
-  ): { [name: string]: Property } {
-    const base =
+  ): Map<string, Property> {
+    const result =
       inherited && this.base
         ? this.base._getProperties(inherited, parentType)
-        : {};
-    return Object.assign(
-      base,
-      indexBy(
-        (this.spec.properties ?? []).map(
-          (p) => new Property(this.system, this.assembly, parentType, this, p),
-        ),
-        (p) => p.name,
-      ),
-    );
+        : new Map<string, Property>();
+    for (const p of this.spec.properties ?? []) {
+      result.set(
+        p.name,
+        new Property(this.system, this.assembly, parentType, this, p),
+      );
+    }
+    return result;
   }
 
   private _getMethods(
     inherited: boolean,
     parentType: ReferenceType,
-  ): { [name: string]: Method } {
-    const base =
+  ): Map<string, Method> {
+    const result =
       inherited && this.base
         ? this.base._getMethods(inherited, parentType)
-        : {};
-    return Object.assign(
-      base,
-      indexBy(
-        (this.spec.methods ?? []).map(
-          (m) => new Method(this.system, this.assembly, parentType, this, m),
-        ),
-        (m) => m.name,
-      ),
-    );
+        : new Map<string, Method>();
+    for (const m of this.spec.methods ?? []) {
+      result.set(
+        m.name,
+        new Method(this.system, this.assembly, parentType, this, m),
+      );
+    }
+    return result;
   }
 }
 

packages/jsii-reflect/lib/interface.ts

@@ -5,7 +5,6 @@ import { Method } from './method';
 import { Property } from './property';
 import { ReferenceType } from './reference-type';
 import { TypeSystem } from './type-system';
-import { indexBy } from './util';
 
 export class InterfaceType extends ReferenceType {
   /** Caches the result of `getInterfaces`. */
@@ -62,15 +61,15 @@ export class InterfaceType extends ReferenceType {
    * @param inherited include all properties inherited from base classes (default: false)
    */
   public getProperties(inherited = false): { [name: string]: Property } {
-    return this._getProperties(inherited, this);
+    return Object.fromEntries(this._getProperties(inherited, this));
   }
 
   /**
    * List all methods in this class.
    * @param inherited include all methods inherited from base classes (default: false)
    */
   public getMethods(inherited = false): { [name: string]: Method } {
-    return this._getMethods(inherited, this);
+    return Object.fromEntries(this._getMethods(inherited, this));
   }
 
   public isDataType() {
@@ -84,42 +83,45 @@ export class InterfaceType extends ReferenceType {
   private _getProperties(
     inherited: boolean,
     parentType: ReferenceType,
-  ): { [name: string]: Property } {
-    const base: { [name: string]: Property } = {};
+  ): Map<string, Property> {
+    const result = new Map<string, Property>();
     if (inherited) {
       for (const parent of this.getInterfaces()) {
-        Object.assign(base, parent._getProperties(inherited, parentType));
+        for (const [key, value] of parent._getProperties(
+          inherited,
+          parentType,
+        )) {
+          result.set(key, value);
+        }
       }
     }
-    return Object.assign(
-      base,
-      indexBy(
-        (this.spec.properties ?? []).map(
-          (p) => new Property(this.system, this.assembly, parentType, this, p),
-        ),
-        (p) => p.name,
-      ),
-    );
+    for (const p of this.spec.properties ?? []) {
+      result.set(
+        p.name,
+        new Property(this.system, this.assembly, parentType, this, p),
+      );
+    }
+    return result;
   }
 
   private _getMethods(
     inherited: boolean,
     parentType: ReferenceType,
-  ): { [name: string]: Method } {
-    const base: { [name: string]: Property } = {};
+  ): Map<string, Method> {
+    const methods = new Map<string, Method>();
     if (inherited) {
       for (const parent of this.getInterfaces()) {
-        Object.assign(base, parent._getMethods(inherited, parentType));
+        for (const [key, value] of parent._getMethods(inherited, parentType)) {
+          methods.set(key, value);
+        }
       }
     }
-    return Object.assign(
-      base,
-      indexBy(
-        (this.spec.methods ?? []).map(
-          (m) => new Method(this.system, this.assembly, parentType, this, m),
-        ),
-        (m) => m.name,
-      ),
-    );
+    for (const m of this.spec.methods ?? []) {
+      methods.set(
+        m.name,
+        new Method(this.system, this.assembly, parentType, this, m),
+      );
+    }
+    return methods;
   }
 }