Allow classes in JS library elements (#21028)

Author: sbc100

src/embind/embind_gen.js

@@ -8,34 +8,34 @@ var LibraryEmbind = {
 
   $moduleDefinitions: [],
 
-  $PrimitiveType: class PrimitiveType {
+  $PrimitiveType: class {
     constructor(typeId, name, destructorType) {
       this.typeId = typeId;
       this.name = name;
       this.destructorType = destructorType;
     }
   },
-  $IntegerType: class IntegerType {
+  $IntegerType: class {
     constructor(typeId) {
       this.typeId = typeId;
       this.destructorType = 'none';
     }
   },
-  $Argument: class Argument {
+  $Argument: class {
     constructor(name, type) {
       this.name = name;
       this.type = type;
     }
   },
-  $UserType: class UserType {
+  $UserType: class {
     constructor(typeId, name) {
       this.typeId = typeId;
       this.name = name;
       this.destructorType = 'none'; // Same as emval.
     }
   },
   $FunctionDefinition__deps: ['$createJsInvoker'],
-  $FunctionDefinition: class FunctionDefinition {
+  $FunctionDefinition: class {
     constructor(name, returnType, argumentTypes, functionIndex, thisType = null, isAsync = false) {
       this.name = name;
       this.returnType = returnType;
@@ -106,7 +106,7 @@ var LibraryEmbind = {
       );
     }
   },
-  $PointerDefinition: class PointerDefinition {
+  $PointerDefinition: class {
     constructor(classType, isConst, isSmartPointer) {
       this.classType = classType;
       this.isConst = isConst;
@@ -117,7 +117,7 @@ var LibraryEmbind = {
       }
     }
   },
-  $ClassDefinition: class ClassDefinition {
+  $ClassDefinition: class {
     constructor(typeId, name, base = null) {
       this.typeId = typeId;
       this.name = name;
@@ -200,7 +200,7 @@ var LibraryEmbind = {
     }
 
   },
-  $ClassProperty: class ClassProperty {
+  $ClassProperty: class {
     constructor(type, name, readonly) {
       this.type = type;
       this.name = name;
@@ -211,7 +211,7 @@ var LibraryEmbind = {
       out.push(`${this.readonly ? 'readonly ' : ''}${this.name}: ${nameMap(this.type)}`);
     }
   },
-  $ConstantDefinition: class ConstantDefinition {
+  $ConstantDefinition: class {
     constructor(type, name) {
       this.type = type;
       this.name = name;
@@ -221,7 +221,7 @@ var LibraryEmbind = {
       out.push(`  ${this.name}: ${nameMap(this.type)};\n`);
     }
   },
-  $EnumDefinition: class EnumDefinition {
+  $EnumDefinition: class {
     constructor(typeId, name) {
       this.typeId = typeId;
       this.name = name;
@@ -255,7 +255,7 @@ var LibraryEmbind = {
       out.push('};\n');
     }
   },
-  $ValueArrayDefinition: class ValueArrayDefinition {
+  $ValueArrayDefinition: class {
     constructor(typeId, name) {
       this.typeId = typeId;
       this.name = name;
@@ -274,7 +274,7 @@ var LibraryEmbind = {
       out.push(' ];\n\n');
     }
   },
-  $ValueObjectDefinition: class ValueObjectDefinition {
+  $ValueObjectDefinition: class {
     constructor(typeId, name) {
       this.typeId = typeId;
       this.name = name;
@@ -294,7 +294,7 @@ var LibraryEmbind = {
       out.push('\n};\n\n');
     }
   },
-  $TsPrinter: class TsPrinter {
+  $TsPrinter: class {
     constructor(definitions) {
       this.definitions = definitions;
       const jsString = 'ArrayBuffer|Uint8Array|Uint8ClampedArray|Int8Array|string';
@@ -360,7 +360,7 @@ var LibraryEmbind = {
     }
   },
 
-  $JsPrinter: class JsPrinter {
+  $JsPrinter: class {
     constructor(definitions) {
       this.definitions = definitions;
     }

src/embind/emval.js

@@ -32,7 +32,7 @@ var LibraryEmVal = {
       {value: true},
       {value: false},
     );
-    emval_handles.reserved = emval_handles.allocated.length
+    Object.assign(emval_handles, /** @lends {emval_handles} */ { reserved: emval_handles.allocated.length }),
     Module['count_emval_handles'] = count_emval_handles;
   },
 

src/jsifier.js

@@ -513,6 +513,8 @@ function(${args}) {
         if (contentText.match(/^\s*([^}]*)\s*=>/s)) {
           // Handle arrow functions
           contentText = `var ${mangled} = ` + contentText + ';';
+        } else if (contentText.startsWith('class ')) {
+          contentText = contentText.replace(/^class /, `class ${mangled} `);
         } else {
           // Handle regular (non-arrow) functions
           contentText = contentText.replace(/function(?:\s+([^(]+))?\s*\(/, `function ${mangled}(`);

src/library.js

@@ -3623,41 +3623,37 @@ addToLibrary({
 #endif
   },
 
-  $handleAllocatorInit: function() {
-    Object.assign(HandleAllocator.prototype, /** @lends {HandleAllocator.prototype} */ {
-      get(id) {
-  #if ASSERTIONS
-        assert(this.allocated[id] !== undefined, `invalid handle: ${id}`);
-  #endif
-        return this.allocated[id];
-      },
-      has(id) {
-        return this.allocated[id] !== undefined;
-      },
-      allocate(handle) {
-        var id = this.freelist.pop() || this.allocated.length;
-        this.allocated[id] = handle;
-        return id;
-      },
-      free(id) {
-  #if ASSERTIONS
-        assert(this.allocated[id] !== undefined);
-  #endif
-        // Set the slot to `undefined` rather than using `delete` here since
-        // apparently arrays with holes in them can be less efficient.
-        this.allocated[id] = undefined;
-        this.freelist.push(id);
-      }
-    });
-  },
-
-  $HandleAllocator__postset: 'handleAllocatorInit()',
-  $HandleAllocator__deps: ['$handleAllocatorInit'],
-  $HandleAllocator__docs: '/** @constructor */',
-  $HandleAllocator: function() {
-    // Reserve slot 0 so that 0 is always an invalid handle
-    this.allocated = [undefined];
-    this.freelist = [];
+  $HandleAllocator: class {
+    constructor() {
+      // TODO(sbc): Use class fields once we allow/enable es2022 in
+      // JavaScript input to acorn and closure.
+      // Reserve slot 0 so that 0 is always an invalid handle
+      this.allocated = [undefined];
+      this.freelist = [];
+    }
+    get(id) {
+#if ASSERTIONS
+      assert(this.allocated[id] !== undefined, `invalid handle: ${id}`);
+#endif
+      return this.allocated[id];
+    };
+    has(id) {
+      return this.allocated[id] !== undefined;
+    };
+    allocate(handle) {
+      var id = this.freelist.pop() || this.allocated.length;
+      this.allocated[id] = handle;
+      return id;
+    };
+    free(id) {
+#if ASSERTIONS
+      assert(this.allocated[id] !== undefined);
+#endif
+      // Set the slot to `undefined` rather than using `delete` here since
+      // apparently arrays with holes in them can be less efficient.
+      this.allocated[id] = undefined;
+      this.freelist.push(id);
+    };
   },
 
   $getNativeTypeSize__deps: ['$POINTER_SIZE'],

src/library_exceptions.js

@@ -20,55 +20,55 @@ var LibraryExceptions = {
   // reference counter) is not protected from that. Also protection is not enough, separate state
   // should be allocated. libcxxabi has concept of dependent exception which is used for that
   // purpose, it references the primary exception.
-  //
-  // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.
-  $ExceptionInfo__docs: '/** @constructor */',
   $ExceptionInfo__deps: [
     '__cxa_is_pointer_type',
 #if EXCEPTION_DEBUG
     '$ptrToString'
 #endif
   ],
-  $ExceptionInfo: function(excPtr) {
-    this.excPtr = excPtr;
-    this.ptr = excPtr - {{{ C_STRUCTS.__cxa_exception.__size__ }}};
+  $ExceptionInfo: class {
+    // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.
+    constructor(excPtr) {
+      this.excPtr = excPtr;
+      this.ptr = excPtr - {{{ C_STRUCTS.__cxa_exception.__size__ }}};
+    }
 
-    this.set_type = function(type) {
+    set_type(type) {
       {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.exceptionType, 'type', '*') }}};
-    };
+    }
 
-    this.get_type = function() {
+    get_type() {
       return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.exceptionType, '*') }}};
-    };
+    }
 
-    this.set_destructor = function(destructor) {
+    set_destructor(destructor) {
       {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.exceptionDestructor, 'destructor', '*') }}};
-    };
+    }
 
-    this.get_destructor = function() {
+    get_destructor() {
       return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.exceptionDestructor, '*') }}};
-    };
+    }
 
-    this.set_caught = function(caught) {
+    set_caught(caught) {
       caught = caught ? 1 : 0;
       {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.caught, 'caught', 'i8') }}};
-    };
+    }
 
-    this.get_caught = function() {
+    get_caught() {
       return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.caught, 'i8') }}} != 0;
-    };
+    }
 
-    this.set_rethrown = function(rethrown) {
+    set_rethrown(rethrown) {
       rethrown = rethrown ? 1 : 0;
       {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.rethrown, 'rethrown', 'i8') }}};
-    };
+    }
 
-    this.get_rethrown = function() {
+    get_rethrown() {
       return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.rethrown, 'i8') }}} != 0;
-    };
+    }
 
     // Initialize native structure fields. Should be called once after allocated.
-    this.init = function(type, destructor) {
+    init(type, destructor) {
 #if EXCEPTION_DEBUG
       dbg('ExceptionInfo init: ' + [type, destructor]);
 #endif
@@ -77,19 +77,19 @@ var LibraryExceptions = {
       this.set_destructor(destructor);
     }
 
-    this.set_adjusted_ptr = function(adjustedPtr) {
+    set_adjusted_ptr(adjustedPtr) {
       {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.adjustedPtr, 'adjustedPtr', '*') }}};
-    };
+    }
 
-    this.get_adjusted_ptr = function() {
+    get_adjusted_ptr() {
       return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.adjustedPtr, '*') }}};
-    };
+    }
 
     // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted
     // when the pointer is casted to some of the exception object base classes (e.g. when virtual
     // inheritance is used). When a pointer is thrown this method should return the thrown pointer
     // itself.
-    this.get_exception_ptr = function() {
+    get_exception_ptr() {
       // Work around a fastcomp bug, this code is still included for some reason in a build without
       // exceptions support.
       var isPointer = ___cxa_is_pointer_type(this.get_type());
@@ -99,7 +99,7 @@ var LibraryExceptions = {
       var adjusted = this.get_adjusted_ptr();
       if (adjusted !== 0) return adjusted;
       return this.excPtr;
-    };
+    }
   },
 
   // Here, we throw an exception after recording a couple of values that we need to remember

src/library_wasmfs_opfs.js

@@ -16,7 +16,7 @@ addToLibrary({
 
 #if !PTHREADS
   // OPFS will only be used on modern browsers that supports JS classes.
-  $FileSystemAsyncAccessHandle: class FileSystemAsyncAccessHandle {
+  $FileSystemAsyncAccessHandle: class {
     // This class implements the same interface as the sync version, but has
     // async reads and writes. Hopefully this will one day be implemented by the
     // platform so we can remove it.

test/code_size/embind_val_wasm.json

@@ -1,10 +1,10 @@
 {
   "a.html": 673,
   "a.html.gz": 431,
-  "a.js": 7468,
-  "a.js.gz": 3137,
+  "a.js": 7426,
+  "a.js.gz": 3122,
   "a.wasm": 11458,
   "a.wasm.gz": 5733,
-  "total": 19599,
-  "total_gz": 9301
+  "total": 19557,
+  "total_gz": 9286
 }

test/other/metadce/test_metadce_cxx_ctors1.gzsize

@@ -1 +1 @@
-10012
+9963

test/other/metadce/test_metadce_cxx_ctors1.jssize

@@ -1 +1 @@
-24846
+24728

test/other/metadce/test_metadce_cxx_ctors2.gzsize

@@ -1 +1 @@
-9995
+9946