Issue 5131 - [emscripten] Clean separation of bindings code and runtime code

compiled/bindings/generator.cpp

Index: compiled/bindings/generator.cpp
===================================================================
rename from compiled/bindings.ipp
rename to compiled/bindings/generator.cpp
--- a/compiled/bindings.ipp
+++ b/compiled/bindings/generator.cpp
@@ -10,389 +10,232 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#pragma once
+#include "generator.h"
 
-#include <cstddef>
-#include <cstdint>
 #include <cstdio>
-#include <cstdlib>
-#include <exception>
-#include <functional>
-#include <map>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
 
-#include <emscripten.h>
-
-#include "String.h"
-#include "intrusive_ptr.h"
+namespace
+{
+  std::vector<bindings_internal::ClassInfo> classes;

[Wladimir Palant, 2017/04/12 14:17:00]

I found two bad assumptions here which went wrong after this refactoring.

1) This was originally a map and I assumed that iterating over it I would get
the members in the order in which they were added. They are actually sorted by
type ID which isn't necessarily incrementing in the order we want. So this is a
vector now, searching it isn't an impact on performance we care about for
bindings generation.

2) ClassInfo::baseClass member was a pointer referring to an instance within
this map. This was a bad idea as pointers to map/vector buffer aren't guaranteed
to stay stable as items are added. So ClassInfo::baseClass is a TYPEID now and
looked up when needed.

[sergei, 2017/04/18 10:46:09]

That's correct, pointers and iterators are invalidated by almost all operations
modifying std::map and vector. One can use iterators of std::list but here I
think having TYPEID value is even better.

+  std::vector<bindings_internal::CustomGenerator> customGenerators;
+}
 
 namespace bindings_internal
 {
-  typedef void* TYPEID;
-
-  enum class TypeCategory
+  FunctionInfo::FunctionInfo()
   {
-    UNKNOWN,
-    VOID,
-    INT,
-    INT64,
-    FLOAT,
-    DEPENDENT_STRING,
-    OWNED_STRING,
-    STRING_REF,
-    CLASS_PTR
-  };
+    name[0] = '\0';
+  }
 
-  template<typename T>
-  struct TypeInfo
+  FunctionInfo::FunctionInfo(TypeCategory returnType, TYPEID pointerType,
+      std::initializer_list<TypeCategory> argTypes, bool instance_function,
+      void* function)
+      : returnType(returnType), pointerType(pointerType),
+        instance_function(instance_function)
   {
-    /*
-     * Since TypeInfo is a templated type, in practice the compiler will define
-     * a new type for each possible template parameter value. We use that fact
-     * to generate type identifiers: each of these TypeInfo types has a
-     * different s_typeIDHelper member, so we use a pointer to that static
-     * variable as a type identifier - it will be different for each template
-     * parameter.
-     */
-    static char s_typeIDHelper;
-    constexpr operator TYPEID() const
+    name[0] = '\0';
+
+    // The function parameter is a pointer to the function pointer.
+    // Emscripten's "function pointers" are actually integers indicating the
+    // position in the call table. 0 represents nullptr.
+    if (!*reinterpret_cast<int*>(function))
+      return;
+
+    std::string signature;
+    if (returnType == TypeCategory::DEPENDENT_STRING ||
+        returnType == TypeCategory::OWNED_STRING)
     {
-      return &s_typeIDHelper;
+      // Objects aren't really returned but passed as parameter. Note that
+      // this pointer might come before it but we don't care because both
+      // are integers (pointers) as far as Emscripten is concerned.
+      signature += "vi";
+    }
+    else if (returnType == TypeCategory::VOID)
+      signature += 'v';
+    else if (returnType == TypeCategory::FLOAT)
+      signature += 'd';
+    else if (returnType == TypeCategory::INT ||
+        returnType == TypeCategory::INT64 ||
+        returnType == TypeCategory::STRING_REF ||
+        returnType == TypeCategory::CLASS_PTR)
+    {
+      signature += 'i';
+    }
+    else
+      throw std::runtime_error("Unexpected function return type");
+
+    if (instance_function)
+    {
+      // this pointer is an implicit parameter
+      signature += 'i';
     }
 
-    constexpr operator TypeCategory() const
-    {
-      if (std::is_void<T>())
-        return TypeCategory::VOID;
-
-      if (std::is_same<T, uint64_t>())
-        return TypeCategory::INT64;
-
-      if (std::is_integral<T>() || std::is_enum<T>())
-        return TypeCategory::INT;
-
-      if (std::is_floating_point<T>())
-        return TypeCategory::FLOAT;
-
-      if (std::is_same<DependentString, T>() || std::is_same<const DependentString, T>())
-        return TypeCategory::DEPENDENT_STRING;
-
-      if (std::is_same<OwnedString, T>() || std::is_same<const OwnedString, T>())
-        return TypeCategory::OWNED_STRING;
-
-      if (std::is_same<String&, T>() || std::is_same<const String&, T>() ||
-        std::is_same<DependentString&, T>())
-      {
-        return TypeCategory::STRING_REF;
-      }
-
-      if (std::is_pointer<T>() && std::is_class<typename std::remove_pointer<T>::type>())
-        return TypeCategory::CLASS_PTR;
-
-      return TypeCategory::UNKNOWN;
-    }
-
-    constexpr TYPEID pointer_type() const
+    for (const auto& item : argTypes)
     {
-      if (std::is_pointer<T>())
-        return TypeInfo<typename std::remove_pointer<T>::type>();
-      else
-        return nullptr;
-    }
-  };
-
-  template<typename T>
-  char TypeInfo<T>::s_typeIDHelper;
-
-  struct FunctionInfo
-  {
-    TypeCategory returnType;
-    TYPEID pointerType;
-    std::vector<TypeCategory> args;
-    bool instance_function;
-    int effectiveArgs;
-    TypeCategory effectiveReturnType;
-    char name[1024];
-
-    FunctionInfo()
-    {
-      name[0] = '\0';
-    }
-
-    FunctionInfo(TypeCategory returnType, TYPEID pointerType,
-        std::initializer_list<TypeCategory> argTypes, bool instance_function,
-        void* function)
-        : returnType(returnType), pointerType(pointerType),
-          instance_function(instance_function)
-    {
-      name[0] = '\0';
-
-      // The function parameter is a pointer to the function pointer.
-      // Emscripten's "function pointers" are actually integers indicating the
-      // position in the call table. 0 represents nullptr.
-      if (!*reinterpret_cast<int*>(function))
-        return;
-
-      std::string signature;
-      if (returnType == TypeCategory::DEPENDENT_STRING ||
-          returnType == TypeCategory::OWNED_STRING)
-      {
-        // Objects aren't really returned but passed as parameter. Note that
-        // this pointer might come before it but we don't care because both
-        // are integers (pointers) as far as Emscripten is concerned.
-        signature += "vi";
-      }
-      else if (returnType == TypeCategory::VOID)
-        signature += 'v';
-      else if (returnType == TypeCategory::FLOAT)
-        signature += 'd';
-      else if (returnType == TypeCategory::INT ||
-          returnType == TypeCategory::INT64 ||
-          returnType == TypeCategory::STRING_REF ||
-          returnType == TypeCategory::CLASS_PTR)
+      if (item == TypeCategory::INT || item == TypeCategory::STRING_REF ||
+          item == TypeCategory::CLASS_PTR)
       {
         signature += 'i';
       }
+      else if (item == TypeCategory::INT64)
+        signature += "ii";
+      else if (item == TypeCategory::FLOAT)
+        signature += 'd';
       else
-        throw std::runtime_error("Unexpected function return type");
-
-      if (instance_function)
-      {
-        // this pointer is an implicit parameter
-        signature += 'i';
-      }
-
-      for (const auto& item : argTypes)
-      {
-        if (item == TypeCategory::INT || item == TypeCategory::STRING_REF ||
-            item == TypeCategory::CLASS_PTR)
-        {
-          signature += 'i';
-        }
-        else if (item == TypeCategory::INT64)
-          signature += "ii";
-        else if (item == TypeCategory::FLOAT)
-          signature += 'd';
-        else
-          throw std::runtime_error("Unexpected function argument type");
-        args.push_back(item);
-      }
-
-      get_function_name(function, signature.c_str());
-    }
-
-    template<typename ReturnType, typename... Args>
-    FunctionInfo(ReturnType (*function)(Args...))
-        : FunctionInfo(TypeInfo<ReturnType>(),
-          TypeInfo<ReturnType>().pointer_type(), { TypeInfo<Args>()... }, false,
-          &function)
-    {
-    }
-
-    template<typename ClassType, typename ReturnType, typename... Args>
-    FunctionInfo(ReturnType (ClassType::*function)(Args...))
-        : FunctionInfo(TypeInfo<ReturnType>(),
-          TypeInfo<ReturnType>().pointer_type(), { TypeInfo<Args>()... }, true,
-          &function)
-    {
-    }
-
-    template<typename ClassType, typename ReturnType, typename... Args>
-    FunctionInfo(ReturnType (ClassType::*function)(Args...) const)
-        : FunctionInfo(TypeInfo<ReturnType>(),
-          TypeInfo<ReturnType>().pointer_type(), { TypeInfo<Args>()... }, true,
-          &function)
-    {
-    }
-
-    bool empty() const
-    {
-      return name[0] == '\0';
+        throw std::runtime_error("Unexpected function argument type");
+      args.push_back(item);
     }
 
-    void get_function_name(void* ptr, const char* signature)
-    {
-      // This is a hack, C++ won't let us get the mangled function name.
-      // JavaScript is more dynamic so we pass the pointer to our function
-      // there. With that and the function signature we can call the function -
-      // with a full stack so that we will cause it to abort. Sometimes the
-      // function we are calling will also be missing from the build. The result
-      // is the same: abort() is called which in turn calls stackTrace(). By
-      // replacing stackTrace() we get access to the call stack and search it
-      // for the name of our function.
-
-      EM_ASM_ARGS({
-        var signature = AsciiToString($2);
-        var args = [];
-        for (var i = 1; i < signature.length; i++)
-          args.push(0);
+    get_function_name(function, signature.c_str());
+  }
 
-        var oldPrint = Module.print;
-        var oldPrintErr = Module.printErr;
-        var oldStackTrace = stackTrace;
-        var sp = Runtime.stackSave();
-        Module.print = function(){};
-        Module.printErr = function(){};
-        stackTrace = function()
-        {
-          var stack = [];
-          for (var f = arguments.callee.caller; f; f = f.caller)
-          {
-            if (f.name)
-            {
-              if (f.name.indexOf("dynCall") == 0)
-                break;
-              else
-                stack.push(f.name);
-            }
-          }
+  bool FunctionInfo::empty() const
+  {
+    return name[0] == '\0';
+  }
 
-          result = stack[stack.length - 1];
-          if (result && result.indexOf("__wrapper") >= 0)
-            result = stack[stack.length - 2];
-          throw result;
-        };
+  void FunctionInfo::get_function_name(void* ptr, const char* signature)
+  {
+    // This is a hack, C++ won't let us get the mangled function name.
+    // JavaScript is more dynamic so we pass the pointer to our function
+    // there. With that and the function signature we can call the function -
+    // with a full stack so that we will cause it to abort. Sometimes the
+    // function we are calling will also be missing from the build. The result
+    // is the same: abort() is called which in turn calls stackTrace(). By
+    // replacing stackTrace() we get access to the call stack and search it
+    // for the name of our function.
 
-        Runtime.stackRestore(STACK_MAX);
+    EM_ASM_ARGS({
+      var signature = AsciiToString($2);
+      var args = [];
+      for (var i = 1; i < signature.length; i++)
+        args.push(0);
 
-        try
-        {
-          Runtime.dynCall(signature, HEAP32[$1 >> 2], args);
-        }
-        catch(e)
+      var oldPrint = Module.print;
+      var oldPrintErr = Module.printErr;
+      var oldStackTrace = stackTrace;
+      var sp = Runtime.stackSave();
+      Module.print = function(){};
+      Module.printErr = function(){};
+      stackTrace = function()
+      {
+        var stack = [];
+        for (var f = arguments.callee.caller; f; f = f.caller)
         {
-          Module.stringToAscii(e, $0);
-        }
-        finally
-        {
-          Runtime.stackRestore(sp);
-          Module.print = oldPrint;
-          Module.printErr = oldPrintErr;
-          stackTrace = oldStackTrace;
+          if (f.name)
+          {
+            if (f.name.indexOf("dynCall") == 0)
+              break;
+            else
+              stack.push(f.name);
+          }
         }
-      }, name, ptr, signature);
-    }
-  };
-
-  class NoBaseClass
-  {
-  };
-
-  struct PropertyInfo
-  {
-    std::string name;
-    FunctionInfo getter;
-    FunctionInfo setter;
-    std::string jsValue;
-  };
 
-  struct MethodInfo
-  {
-    std::string name;
-    FunctionInfo call;
-  };
-
-  struct DifferentiatorInfo
-  {
-    size_t offset;
-    std::vector<std::pair<int, std::string>> mapping;
-  };
+        result = stack[stack.length - 1];
+        if (result && result.indexOf("__wrapper") >= 0)
+          result = stack[stack.length - 2];
+        throw result;
+      };
 
-  struct ClassInfo
+      Runtime.stackRestore(STACK_MAX);
+
+      try
+      {
+        Runtime.dynCall(signature, HEAP32[$1 >> 2], args);
+      }
+      catch(e)
+      {
+        Module.stringToAscii(e, $0);
+      }
+      finally
+      {
+        Runtime.stackRestore(sp);
+        Module.print = oldPrint;
+        Module.printErr = oldPrintErr;
+        stackTrace = oldStackTrace;
+      }
+    }, name, ptr, signature);
+  }
+
+  ClassInfo* find_class(TYPEID classID)
   {
-    ClassInfo* baseClass;
-    std::string name;
-    std::vector<PropertyInfo> properties;
-    std::vector<MethodInfo> methods;
-    DifferentiatorInfo subclass_differentiator;
-    ptrdiff_t ref_counted_offset;
-  };
-
-  typedef std::function<void()>  CustomGenerator;
-
-  std::map<TYPEID, ClassInfo> classes;
-  std::vector<CustomGenerator> customGenerators;
+    for (auto& classInfo : classes)
+      if (classInfo.id == classID)
+        return &classInfo;
+    return nullptr;
+  }
 
   void register_class(const char* name, TYPEID classID, TYPEID baseClassID,
                       ptrdiff_t ref_counted_offset)
   {
-    auto it = classes.find(classID);
-    if (it != classes.end())
+    if (find_class(classID))
       throw std::runtime_error(std::string("Duplicate definition for class ") + name);
 
-    ClassInfo* baseClass = nullptr;
-    if (baseClassID != TypeInfo<NoBaseClass>())
-    {
-      it = classes.find(baseClassID);
-      if (it == classes.end())
-        throw std::runtime_error(std::string("Unknown base class defined for class ") + name);
-      baseClass = &(it->second);
-    }
+    if (baseClassID != TypeInfo<NoBaseClass>() && !find_class(baseClassID))
+      throw std::runtime_error(std::string("Unknown base class defined for class ") + name);
 
     ClassInfo classInfo;
-    classInfo.baseClass = baseClass;
+    classInfo.id = classID;
+    classInfo.baseClass = baseClassID;
     classInfo.name = name;
     classInfo.subclass_differentiator.offset = SIZE_MAX;
     classInfo.ref_counted_offset = ref_counted_offset;
-    classes[classID] = classInfo;
+    classes.push_back(classInfo);
   }
 
   void register_property(TYPEID classID, const char* name,
       const FunctionInfo& getter, const FunctionInfo& setter,
-      const char* jsValue = "")
+      const char* jsValue)
   {
-    auto it = classes.find(classID);
-    if (it == classes.end())
+    ClassInfo* classInfo = find_class(classID);
+    if (!classInfo)
       throw std::runtime_error(std::string("Property defined on unknown class: ") + name);
 
     PropertyInfo propertyInfo;
     propertyInfo.name = name;
     propertyInfo.getter = getter;
     propertyInfo.setter = setter;
     propertyInfo.jsValue = jsValue;
-    it->second.properties.push_back(propertyInfo);
+    classInfo->properties.push_back(propertyInfo);
   }
 
   void register_method(TYPEID classID, const char* name,
       const FunctionInfo& call)
   {
-    auto it = classes.find(classID);
-    if (it == classes.end())
+    ClassInfo* classInfo = find_class(classID);
+    if (!classInfo)
       throw std::runtime_error(std::string("Method defined on unknown class: ") + name);
 
     MethodInfo methodInfo;
     methodInfo.name = name;
     methodInfo.call = call;
-    it->second.methods.push_back(methodInfo);
+    classInfo->methods.push_back(methodInfo);
   }
 
   void register_differentiator(TYPEID classID, size_t offset,
       std::vector<std::pair<int, std::string>>& mapping)
   {
-    auto it = classes.find(classID);
-    if (it == classes.end())
+    ClassInfo* classInfo = find_class(classID);
+    if (!classInfo)
       throw std::runtime_error("Subclass differentiator defined on unknown class");
 
-    if (it->second.subclass_differentiator.offset != SIZE_MAX)
-      throw std::runtime_error("More than one subclass differentiator defined for class " + it->second.name);
+    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;
-    it->second.subclass_differentiator = differentiatorInfo;
+    classInfo->subclass_differentiator = differentiatorInfo;
   }
 
   const std::string generateCall(const FunctionInfo& call,
       std::vector<std::string>& params)
   {
     if (call.returnType == TypeCategory::DEPENDENT_STRING ||
         call.returnType == TypeCategory::OWNED_STRING)
     {
@@ -441,26 +284,25 @@ namespace bindings_internal
     }
     else if (call.returnType == TypeCategory::CLASS_PTR)
     {
       std::string result;
       result += "  var result = " + call_str + ";\n";
       result += "  if (result)\n";
       result += "  {\n";
 
-      auto it = classes.find(call.pointerType);
-      if (it == classes.end())
+      const ClassInfo* cls = find_class(call.pointerType);
+      if (!cls)
         throw std::runtime_error("Function " + std::string(call.name) + " returns pointer to unknown class");
 
-      const ClassInfo& cls = it->second;
-      auto offset = cls.subclass_differentiator.offset;
+      auto offset = cls->subclass_differentiator.offset;
       if (offset == SIZE_MAX)
-        result += "    result = exports." + cls.name + "(result);\n";
+        result += "    result = exports." + cls->name + "(result);\n";
       else
-        result += "    result = exports." + cls.name + ".fromPointer(result);\n";
+        result += "    result = exports." + cls->name + ".fromPointer(result);\n";
 
       result += "  }\n";
       result += "  else\n";
       result += "    result = null;\n";
       return result;
     }
     else
       throw std::runtime_error("Unexpected return type for " + std::string(call.name));
@@ -573,18 +415,19 @@ namespace bindings_internal
         };
         return result;
       }
     )");
   }
 
   void printClass(const ClassInfo& cls)
   {
+    ClassInfo* baseClass = find_class(cls.baseClass);
     printf("exports.%s = createClass(%s, %i);\n", cls.name.c_str(),
-        (cls.baseClass ? ("exports." + cls.baseClass->name).c_str() : "null"),
+        (baseClass ? ("exports." + baseClass->name).c_str() : "null"),
         cls.ref_counted_offset);
 
     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)
@@ -618,166 +461,25 @@ namespace bindings_internal
     {
       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());
     }
   }
-
-  void printBindings()
-  {
-    printHelpers();
-
-    for (const auto& item : classes)
-      printClass(item.second);
-
-    for (const auto& item : customGenerators)
-      item();
-  }
 }
 
-#if defined(PRINT_BINDINGS)
-  // Bindings generation step: collect bindings information and print
-  // corresponding JS code.
-  #define EMSCRIPTEN_BINDINGS \
-      void InitializeBindings();\
-      int main()\
-      {\
-        try\
-        {\
-          InitializeBindings();\
-          bindings_internal::printBindings();\
-        }\
-        catch (const std::exception& e)\
-        {\
-          EM_ASM_ARGS(\
-            console.error("Error occurred generating JavaScript bindings: " +\
-                Module.AsciiToString($0)), e.what()\
-          );\
-          abort();\
-        }\
-        return 0;\
-      }\
-      void InitializeBindings()
-#else
-  // Actual compilation step: ignore bindings information but define some
-  // exported helper functions necessary for the bindings.
-  #define EMSCRIPTEN_BINDINGS \
-      extern "C"\
-      {\
-        void EMSCRIPTEN_KEEPALIVE InitString(DependentString* str,\
-            String::value_type* data, String::size_type len)\
-        {\
-          /* String is already allocated on stack, we merely need to call*/\
-          /* constructor.*/\
-          new (str) DependentString(data, len);\
-        }\
-        void EMSCRIPTEN_KEEPALIVE DestroyString(OwnedString* str)\
-        {\
-          /* Stack memory will be freed automatically, we need to call*/\
-          /* destructor explicitly however.*/\
-          str->~OwnedString();\
-        }\
-        String::size_type EMSCRIPTEN_KEEPALIVE GetStringLength(\
-            const String& str)\
-        {\
-          return str.length();\
-        }\
-        const String::value_type* EMSCRIPTEN_KEEPALIVE GetStringData(\
-            const String& str)\
-        {\
-          return str.data();\
-        }\
-        void EMSCRIPTEN_KEEPALIVE ReleaseRef(ref_counted* ptr)\
-        {\
-          ptr->ReleaseRef();\
-        }\
-      }\
-      void BindingsInitializer_dummy()
-#endif
-
-template<typename ClassType,
-    typename BaseClass = bindings_internal::NoBaseClass,
-    typename std::enable_if<std::is_base_of<ref_counted, ClassType>::value>::type* = nullptr>
-class class_
+void printBindings()
 {
-public:
-  class_(const char* name)
-  {
-    ClassType* ptr = reinterpret_cast<ClassType*>(0x10000000);
-    ptrdiff_t ref_counted_offset =
-        reinterpret_cast<char*>(static_cast<ref_counted*>(ptr)) -
-        reinterpret_cast<char*>(ptr);
-    bindings_internal::register_class(name,
-        bindings_internal::TypeInfo<ClassType>(),
-        bindings_internal::TypeInfo<BaseClass>(),
-        ref_counted_offset
-      );
-  }
-
-  template<typename FieldType>
-  const class_& property(const char* name,
-      FieldType (ClassType::*getter)() const,
-      void (ClassType::*setter)(FieldType) = nullptr) const
-  {
-    bindings_internal::register_property(
-        bindings_internal::TypeInfo<ClassType>(), name, getter, setter);
-    return *this;
-  }
-
-  const class_& class_property(const char* name,
-      const char* jsValue) const
-  {
-    bindings_internal::register_property(
-        bindings_internal::TypeInfo<ClassType>(), name,
-        bindings_internal::FunctionInfo(), bindings_internal::FunctionInfo(),
-        jsValue);
-    return *this;
-  }
+  bindings_internal::printHelpers();
 
-  template<typename ReturnType, typename... Args>
-  const class_& function(const char* name, ReturnType (ClassType::*method)(Args...)) const
-  {
-    bindings_internal::register_method(
-        bindings_internal::TypeInfo<ClassType>(), name, method);
-    return *this;
-  }
-
-  template<typename ReturnType, typename... Args>
-  const class_& function(const char* name, ReturnType (ClassType::*method)(Args...) const) const
-  {
-    bindings_internal::register_method(
-        bindings_internal::TypeInfo<ClassType>(), name, method);
-    return *this;
-  }
+  for (const auto& item : classes)
+    bindings_internal::printClass(item);
 
-  template<typename ReturnType, typename... Args>
-  const class_& class_function(const char* name, ReturnType (*method)(Args...)) const
-  {
-    bindings_internal::register_method(
-        bindings_internal::TypeInfo<ClassType>(), name, method);
-    return *this;
-  }
-
-  template<typename ReturnType,
-      typename std::enable_if<std::is_convertible<ReturnType, int32_t>::value>::type* = nullptr>
-  const class_& subclass_differentiator(ReturnType ClassType::* member,
-      std::initializer_list<std::pair<ReturnType, const char*>> list) const
-  {
-    ClassType* instance = nullptr;
-    size_t offset = (char*)&(instance->*member) - (char*)instance;
-
-    std::vector<std::pair<int, std::string>> mapping;
-    for (const auto& item : list)
-      mapping.emplace_back(item.first, item.second);
-
-    bindings_internal::register_differentiator(
-        bindings_internal::TypeInfo<ClassType>(), offset, mapping);
-    return *this;
-  }
-};
+  for (const auto& item : customGenerators)
+    item();
+}
 
 void custom_generator(bindings_internal::CustomGenerator generator)
 {
-  bindings_internal::customGenerators.push_back(generator);
+  customGenerators.push_back(generator);
 }