Issue 5185 - [emscripten] More compact definition of class prototypes

compiled/bindings/generator.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 235 matching lines @@
 
     if (classInfo->subclass_differentiator.offset != SIZE_MAX)
       throw std::runtime_error("More than one subclass differentiator defined for class " + classInfo->name);
 
     DifferentiatorInfo differentiatorInfo;
     differentiatorInfo.offset = offset;
     differentiatorInfo.mapping = mapping;
     classInfo->subclass_differentiator = differentiatorInfo;
   }
 
-  const std::string generateCall(const FunctionInfo& call,
+  std::string generateCall(const FunctionInfo& call,
       std::vector<std::string>& params)
   {
     if (call.returnType == TypeCategory::DEPENDENT_STRING ||
         call.returnType == TypeCategory::OWNED_STRING)
     {
       params.insert(params.begin(), "string");
     }
 
     std::string call_str(call.name);
     call_str += "(";
@@ skipping 50 matching lines @@
         result += "  }\n";
         result += "  else\n";
         result += "    result = null;\n";
         return result;
       }
       default:
         throw std::runtime_error("Unexpected return type for " + std::string(call.name));
     }
   }
 
-  const std::string wrapCall(const FunctionInfo& call)
+  std::string wrapCall(const FunctionInfo& call, bool isFunction)
   {
     bool hasStringArgs = false;
     std::vector<std::string> params;
-    std::string prefix = "function(";
+    std::string prefix;
+
+    if (isFunction)
+      prefix += "function";
+    prefix += "(";
     for (int i = 0; i < call.args.size(); i++)
     {
       std::string argName("arg" + std::to_string(i));
       if (i > 0)
         prefix += ", ";
       prefix += argName;
 
       if (call.args[i] == TypeCategory::STRING_REF)
       {
         hasStringArgs = true;
@@ skipping 22 matching lines @@
       prefix += "  var sp = Runtime.stackSave();\n";
       suffix = "  Runtime.stackRestore(sp);\n" + suffix;
     }
 
     if (call.instance_function)
       params.insert(params.begin(), "this._pointer");
 
     return prefix + generateCall(call, params) + suffix;
   }
 
-  std::string generatePropertyDescriptor(const PropertyInfo& property)
-  {
-    if (!property.jsValue.empty())
-      return "value: " + property.jsValue;
-
-    std::string result("get: " + wrapCall(property.getter));
-    if (!property.setter.empty())
-      result += ", set: " + wrapCall(property.setter);
-    return result;
-  }
-
   void printHelpers()
   {
     printf("var sizeofString = %i;\n", sizeof(String));
 
     puts(R"(
       function copyString(str, buffer)
       {
         var length = str.length;
         for (var i = 0, pointer = (buffer >> 1); i < length; i++, pointer++)
           HEAP16[pointer] = str.charCodeAt(i);
@@ skipping 15 matching lines @@
         return result;
       }
 
       function readString(str)
       {
         var length = Module._GetStringLength(str);
         var pointer = Module._GetStringData(str) >> 1;
         return String.fromCharCode.apply(String, HEAP16.slice(pointer, pointer + length));
       }
 
-      function createClass(superclass, ref_counted_offset)
+      function createClass(superclass, ref_counted_offset, props)
       {
         var result = function(pointer)
         {
           this._pointer = pointer;
         };
-        if (superclass)
-          result.prototype = Object.create(superclass.prototype);
+        var proto = (superclass ? superclass.prototype : null);
+        result.prototype = Object.create(proto, Object.getOwnPropertyDescriptors(props));
         result.prototype.delete = function()
         {
           Module._ReleaseRef(this._pointer + ref_counted_offset);
         };
         return result;
       }
     )");
   }
 
   void printClass(const ClassInfo& cls)
   {
+    // Begin class definition
+
     ClassInfo* baseClass = find_class(cls.baseClass);
-    printf("exports.%s = createClass(%s, %i);\n", cls.name.c_str(),
+    printf("exports.%s = createClass(%s, %i, {\n", cls.name.c_str(),
         (baseClass ? ("exports." + baseClass->name).c_str() : "null"),
         cls.ref_counted_offset);
 
+    // Print prototype members
+
+    for (const auto& property : cls.properties)
+    {
+      if (property.jsValue.empty())
+      {
+        printf("get %s%s,\n", property.name.c_str(),
+               wrapCall(property.getter, false).c_str());
+        if (!property.setter.empty())
+        {
+          printf("set %s%s,\n", property.name.c_str(),
+                 wrapCall(property.setter, false).c_str());
+        }
+      }
+      else
+        printf("%s: %s,\n", property.name.c_str(), property.jsValue.c_str());
+    }
+
+    for (const auto& method : cls.methods)
+      if (method.call.instance_function)
+        printf("%s: %s,\n", method.name.c_str(), wrapCall(method.call).c_str());
+
+    // End class definition
+
+    printf("});\n");
+
+    // Print static members
+
     DifferentiatorInfo differentiator = cls.subclass_differentiator;
     if (differentiator.offset != SIZE_MAX)
     {
       printf("var %s_mapping = \n", cls.name.c_str());
       puts("{");
       for (const auto& item : differentiator.mapping)
         printf("  %i: '%s',\n", item.first, item.second.c_str());
       puts("};");
 
       printf("exports.%s.fromPointer = function(ptr)\n", cls.name.c_str());
       puts("{");
       printf("  var type = HEAP32[ptr + %i >> 2];\n", differentiator.offset);
       printf("  if (type in %s_mapping)\n", cls.name.c_str());
       printf("    return new (exports[%s_mapping[type]])(ptr);\n", cls.name.c_str());
       printf("  throw new Error('Unexpected %s type: ' + type);\n", cls.name.c_str());
       puts("};");
     }
     else
     {
       printf("exports.%s.fromPointer = function(ptr)\n", cls.name.c_str());
       puts("{");
       printf("  return new exports.%s(ptr);\n", cls.name.c_str());
       puts("};");
     }
 
-    for (const auto& item : cls.properties)
+    for (const auto& method : cls.methods)
     {
-      printf("Object.defineProperty(exports.%s.prototype, '%s', {%s});\n",
-          cls.name.c_str(), item.name.c_str(),
-          generatePropertyDescriptor(item).c_str());
-    }
-
-    for (const auto& item : cls.methods)
-    {
-      std::string obj("exports." + cls.name);
-      if (item.call.instance_function)
-        obj += ".prototype";
-      printf("%s.%s = %s;\n", obj.c_str(), item.name.c_str(),
-          wrapCall(item.call).c_str());
+      if (!method.call.instance_function)
+      {
+        printf("exports.%s.%s = %s;\n", cls.name.c_str(), method.name.c_str(),
+               wrapCall(method.call).c_str());
+      }
     }
   }
 }
 
 void printBindings()
 {
   bindings_internal::printHelpers();
 
   for (const auto& item : classes)
     bindings_internal::printClass(item);
 }