Generate a monomorphic version of .createReadOnly, .instantiate and .is for each class model

The VScode Deopt explorer showed that `.createReadOnly` inside the class model `register` function was getting deoptimized because it closes over too-wide a variety of `klass` variable references. We're closing over it so it is correct, but to v8, the callsite is still the same I guess, so it has to deoptimize to pull the right value for the closure! Same for .is and .instantiate -- these dynamically produced functions make a huge difference if they are re-eval'd for each class instead of defined dynamically.

Removing this deoptimization almost 2x'd to the large root benchmark for me!

Author: airhorns

src/class-model.ts

@@ -252,25 +252,7 @@ export function register<Instance, Klass extends { new (...args: any[]): Instanc
   klass.volatiles = mstVolatiles;
 
   // conform to the API that the other MQT types expect for creating instances
-  klass.instantiate = (snapshot, context, parent) => new klass(snapshot, context, parent);
-  (klass as any).is = (value: any) => value instanceof klass || klass.mstType.is(value);
   klass.create = (snapshot, env) => klass.mstType.create(snapshot, env);
-  klass.createReadOnly = (snapshot, env) => {
-    const context: InstantiateContext = {
-      referenceCache: new Map(),
-      referencesToResolve: [],
-      env,
-    };
-
-    const instance = new klass(snapshot, context, null) as any;
-
-    for (const resolver of context.referencesToResolve) {
-      resolver();
-    }
-
-    return instance;
-  };
-
   klass.schemaHash = memoize(async () => {
     const props = Object.entries(klass.properties as Record<string, IAnyType>).sort(([key1], [key2]) => key1.localeCompare(key2));
     const propHashes = await Promise.all(props.map(async ([key, prop]) => `${key}:${await prop.schemaHash()}`));
@@ -288,7 +270,12 @@ export function register<Instance, Klass extends { new (...args: any[]): Instanc
     (klass as any).mstType = (klass as any).mstType.volatile((self: any) => initializeVolatiles({}, self, mstVolatiles));
   }
 
+  // define the class constructor and the following hot path functions dynamically
+  // .createReadOnly
+  // .is
+  // .instantiate
   klass = buildFastInstantiator(klass);
+
   (klass as any)[$registered] = true;
 
   return klass as any;

src/fast-instantiator.ts

@@ -74,11 +74,40 @@ class InstantiatorBuilder<T extends IClassModelType<Record<string, IAnyType>, an
     `);
     }
 
+    let className = this.model.name;
+    if (!className || className.trim().length == 0) {
+      className = "AnonymousModel";
+    }
+
     const defineClassStatement = `
-      return class ${this.model.name} extends model {
+      return class ${className} extends model {
         [$memos] = null;
         [$memoizedKeys] = null;
 
+        static createReadOnly = (snapshot, env) => {
+          const context = {
+            referenceCache: new Map(),
+            referencesToResolve: [],
+            env,
+          };
+      
+          const instance = new ${className}(snapshot, context, null);
+      
+          for (const resolver of context.referencesToResolve) {
+            resolver();
+          }
+      
+          return instance;
+        };
+
+        static instantiate(snapshot, context, parent) { 
+          return new ${className}(snapshot, context, parent);
+        };
+        
+        static is(value) {
+          return (value instanceof ${className}) || ${className}.mstType.is(value);
+        };
+
         constructor(
           snapshot,
           context,
@@ -119,13 +148,19 @@ class InstantiatorBuilder<T extends IClassModelType<Record<string, IAnyType>, an
 
     // console.log(`function for ${this.model.name}`, "\n\n\n", aliasFuncBody, "\n\n\n");
 
-    // build a function that closes over a bunch of aliased expressions
-    // evaluate the inner function source code in this closure to return the function
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    const aliasFunc = new Function("model", "imports", aliasFuncBody);
+    try {
+      // build a function that closes over a bunch of aliased expressions
+      // evaluate the inner function source code in this closure to return the function
+      // eslint-disable-next-line @typescript-eslint/no-implied-eval
+      const aliasFunc = new Function("model", "imports", aliasFuncBody);
 
-    // evaluate aliases and get created inner function
-    return aliasFunc(this.model, { $identifier, $env, $parent, $memos, $memoizedKeys, $readOnly, $type, QuickMap, QuickArray }) as T;
+      // evaluate aliases and get created inner function
+      return aliasFunc(this.model, { $identifier, $env, $parent, $memos, $memoizedKeys, $readOnly, $type, QuickMap, QuickArray }) as T;
+    } catch (e) {
+      console.warn("failed to build fast instantiator for", this.model.name);
+      console.warn("dynamic source code:", aliasFuncBody);
+      throw e;
+    }
   }
 
   private expressionForDirectlyAssignableType(key: string, type: DirectlyAssignableType) {