Issue 4125 - [emscripten] Convert filter classes to C++

compiled/bindings.ipp

 #pragma once

[sergei, 2016/06/16 21:16:53]

Why does it not print 'use strict;'?

[sergei, 2016/06/16 21:16:57]

Why are "-1" at the beginning of compiled/bindings.js?

[sergei, 2016/06/16 21:17:08]

I don't think that it is worth paying attention to comments regarding style in
this file, I left some of them only for reference.

[Wladimir Palant, 2016/12/06 10:47:55]

The bindings are only a small part of the resulting file. If we want "use
strict" it should be added to shell.js which goes at the very top. I added it
but it doesn't help much with generated code.

[Wladimir Palant, 2016/12/06 10:48:12]

That's output from an abort() call not being suppressed. It might be that you
are using an Emscripten version that is different from 1.35.0 that this has been
tested against. The function name resolving here relies on Emscripten internals
so it won't just work against any Emscripten version.

 
+#include <cstddef>
+#include <cstdint>
 #include <cstdio>
 #include <cstdlib>
-#include <cstring>
 #include <exception>
 #include <map>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>

[sergei, 2016/06/16 21:16:50]

What do you think about excluding std classes from the resulting JS completely?
We can still use them to generate bindings.

For EMSCRIPTEN_BINDINGS when PRINT_BINDINGS is not defined we don't need most of
these headers, I expect the result code to be much smaller if we completely
exclude <vector>, <map>, <string>, <exception> from all files. I do believe that
anyway emcc removes not used code from the final result but if we can do it
explicitly it can be even better.

BTW, currently we don't need to include <cstring> and <cstdio>.

[Wladimir Palant, 2016/12/06 10:48:00]

Headers don't result in any code, they are merely definitions. If anything, this
will marginally speed up the build but I don't think that we are at a stage
where we should put effort into that.
<cstdio> is necessary for puts(). As to <cstring>, this indeed appears to be
unused.

 
 #include <emscripten.h>
 
 #include "String.h"
 #include "intrusive_ptr.h"
 
 namespace bindings_internal

[sergei, 2016/06/16 21:17:05]

It would be good to have some comment here which explains what is happening and
why we need it. May be it should be somewhere in readme file. As I see it, this
file is devoted to generating the glue code to have an ability to call JS code
converted from C++ from regular JS code because we don't know the names of
methods in the generated code. The process of obtaining of the glue code is (see
"compile" file):
- compile C++ code and bindings with -DPRINT_BINDINGS using emcc
- run the generated JS code to generate the glue code.

It's also important to document somewhere that bindings define new classes which
accept "pointer" to C++ object in the constructor, where "pointer" refers to a
reference to an instance of corresponding JS object from JS generated from C++.

Of course it's all clear from the code but I think that short summary at the
beginning of the file will help to faster get head around it.

[Wladimir Palant, 2016/12/06 10:47:52]

With the approach changing with each iteration, I wasn't in a hurry to write
documentation of course. But it seems that the current approach is close to what
we will end up with so I'll write some documentation.

 {
   typedef void* TYPEID;
 
   enum class TypeCategory
   {
     UNKNOWN,
     VOID,
     INT,
     DEPENDENT_STRING,
     OWNED_STRING,
     STRING_REF,
     CLASS_PTR
   };
 
   template<typename T>
   struct TypeInfo
   {
-    static char c;

[sergei, 2016/06/16 21:17:10]

I think it would be better to call it something like "s_typeIDHelper" and put a
comment about the used trick here, something like the following:

The pointer to it is used as TYPEID.
It's not initialized to any specific value because we don't use the value of it,
thus the type of it (char) is also not important, however we use the pointer to
it (which is implicitly casted to TYPEID which is void*). We can do it because
the compiler instantiates a new static member for each TypeInfo<T>, so we get
different pointer &TypeInfo<T>::c values for different T.

[Wladimir Palant, 2016/12/06 10:47:59]

Done.

+    /*
+     * 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
     {
-      return &c;
+      return &s_typeIDHelper;
     }
 
     constexpr operator TypeCategory() const
     {
       if (std::is_void<T>())
         return TypeCategory::VOID;
 
       if (std::is_integral<T>() || std::is_enum<T>())
         return TypeCategory::INT;
 
-      if (std::is_same<DependentString,T>() || std::is_same<const DependentString,T>())
+      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>())
+      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>())
+      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;
     }
 
-    TYPEID pointer_type() const

[sergei, 2016/06/16 21:16:51]

Actually it might be makes sense to make the method also constexpr.

[Wladimir Palant, 2016/12/06 10:47:42]

Done.

+    constexpr TYPEID pointer_type() const
     {
       if (std::is_pointer<T>())
         return TypeInfo<typename std::remove_pointer<T>::type>();
       else
         return nullptr;
     }
   };
 
   template<typename T>
-  char TypeInfo<T>::c;
+  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;

[sergei, 2016/06/16 21:17:02]

Although it makes no difference I personally prefer to write '\0' to emphasize
that it's a character.

[Wladimir Palant, 2016/12/06 10:47:39]

Done.

+      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;
+      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;
 
-      for (auto it = argTypes.begin(); it != argTypes.end(); ++it)
+      for (const auto& item : argTypes)
       {
-        if (*it != TypeCategory::INT && *it != TypeCategory::STRING_REF &&
-            *it != TypeCategory::CLASS_PTR)
+        if (item != TypeCategory::INT && item != TypeCategory::STRING_REF &&
+            item != TypeCategory::CLASS_PTR)
         {
           throw std::runtime_error("Unexpected function argument type");
         }
-        args.push_back(*it);
+        args.push_back(item);
       }
 
       if (returnType != TypeCategory::VOID && returnType != TypeCategory::INT &&
           returnType != TypeCategory::DEPENDENT_STRING &&
           returnType != TypeCategory::OWNED_STRING &&
           returnType != TypeCategory::STRING_REF &&
           returnType != TypeCategory::CLASS_PTR)
       {
         throw std::runtime_error("Unexpected function return type");
       }
@@ skipping 33 matching lines @@
     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;
+      return name[0] == '\0';
     }
 
     void get_function_name(void* ptr, int numArgs, bool voidResult)
     {
       // 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
@@ skipping 69 matching lines @@
   };
 
   struct MethodInfo
   {
     std::string name;
     FunctionInfo call;
   };
 
   struct DifferentiatorInfo
   {
-    FunctionInfo call;
-    std::vector<std::pair<int,std::string>> mapping;
+    size_t offset;
+    std::vector<std::pair<int, std::string>> mapping;
   };
 
   struct ClassInfo
   {
     ClassInfo* baseClass;
     std::string name;
     std::vector<PropertyInfo> properties;
     std::vector<MethodInfo> methods;
     std::vector<FunctionInfo> initializers;
     DifferentiatorInfo subclass_differentiator;
+    ptrdiff_t ref_counted_offset;
   };
 
-  std::map<TYPEID,ClassInfo> classes;
-
-  void register_class(const char* name, TYPEID classID, TYPEID baseClassID)
+  std::map<TYPEID, ClassInfo> classes;
+
+  void register_class(const char* name, TYPEID classID, TYPEID baseClassID,
+                      ptrdiff_t ref_counted_offset)
   {
     auto it = classes.find(classID);
     if (it != classes.end())
       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);
     }
 
     ClassInfo classInfo;
     classInfo.baseClass = baseClass;
     classInfo.name = name;
+    classInfo.subclass_differentiator.offset = SIZE_MAX;
+    classInfo.ref_counted_offset = ref_counted_offset;
     classes[classID] = classInfo;
   }
 
   void register_property(TYPEID classID, const char* name,
       const FunctionInfo& getter, const FunctionInfo& setter,
       const char* jsValue = "")
   {
     auto it = classes.find(classID);
     if (it == classes.end())
       throw std::runtime_error(std::string("Property defined on unknown class: ") + name);
@@ skipping 21 matching lines @@
 
   void register_initializer(TYPEID classID, const FunctionInfo& call)
   {
     auto it = classes.find(classID);
     if (it == classes.end())
       throw std::runtime_error("Initializer defined on unknown class");
 
     it->second.initializers.push_back(call);
   }
 
-  void register_differentiator(TYPEID classID, const FunctionInfo& call,
-      std::vector<std::pair<int,std::string>>& mapping)
+  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())
       throw std::runtime_error("Subclass differentiator defined on unknown class");
 
-    if (!it->second.subclass_differentiator.call.empty())
+    if (it->second.subclass_differentiator.offset != SIZE_MAX)
       throw std::runtime_error("More than one subclass differentiator defined for class " + it->second.name);
 
     DifferentiatorInfo differentiatorInfo;
-    differentiatorInfo.call = call;
+    differentiatorInfo.offset = offset;
     differentiatorInfo.mapping = mapping;
     it->second.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)
     {
@@ skipping 13 matching lines @@
     if (call.returnType == TypeCategory::VOID)
       return "  " + call_str + ";\n";
     else if (call.returnType == TypeCategory::INT)
       return "  var result = " + call_str + ";\n";
     else if (call.returnType == TypeCategory::DEPENDENT_STRING ||
         call.returnType == TypeCategory::OWNED_STRING)
     {
       std::string result;
       result += "  var string = createString();\n";
       result += "  " + call_str + ";\n";
-      result += "  var result = getStringData(string);\n";
+      result += "  var result = readString(string);\n";
       if (call.returnType == TypeCategory::OWNED_STRING)
         result += "  Module._DestroyString(string);\n";
       return result;
     }
     else if (call.returnType == TypeCategory::STRING_REF)
     {
-      return "  var result = getStringData(" + call_str + ");\n";
+      return "  var result = readString(" + call_str + ");\n";
     }
     else if (call.returnType == TypeCategory::CLASS_PTR)
     {
       std::string result;
       result += "  var result = " + call_str + ";\n";
       result += "  if (result)\n";
       result += "  {\n";
-      result += "    Module._AddRef(result);\n";
 
       auto it = classes.find(call.pointerType);
       if (it == classes.end())
         throw std::runtime_error("Function " + std::string(call.name) + " returns pointer to unknown class");
 
       const ClassInfo& cls = it->second;
-      if (cls.subclass_differentiator.call.empty())
+      auto offset = cls.subclass_differentiator.offset;
+      if (offset == SIZE_MAX)
         result += "    result = " + cls.name + "(result);\n";
       else
       {
-        result += "    var type = " +
-            std::string(cls.subclass_differentiator.call.name) + "(result);\n";
+        result += "    var type = HEAP32[result + " + std::to_string(offset)+ " >> 2];\n";
         result += "    if (type in " + cls.name + "_mapping)\n";
         result += "      result = new (exports[" + cls.name + "_mapping[type]])(result);\n";
         result += "    else\n";
         result += "      throw new Error('Unexpected " + cls.name + " type: ' + type);\n";
       }
 
       result += "  }\n";
       return result;
     }
     else
       throw std::runtime_error("Unexpected return type for " + std::string(call.name));
   }
 
   const std::string wrapCall(const FunctionInfo& call)
   {
     char buffer[20];
     bool hasStringArgs = false;
     std::vector<std::string> params;
     std::string prefix = "function(";
     for (int i = 0; i < call.args.size(); i++)
     {
       sprintf(buffer, "arg%i", i);
       if (i > 0)
         prefix += ", ";
       prefix += buffer;
-

[sergei, 2016/06/16 21:16:45]

Additional line.

[Wladimir Palant, 2016/12/06 10:47:57]

Done.

 
       if (call.args[i] == TypeCategory::STRING_REF)
       {
         hasStringArgs = true;
         params.push_back(std::string("createString(") + buffer + ")");
       }
       else
         params.push_back(buffer);
     }
     prefix += ")\n{\n";
 
     std::string suffix = "}";
     if (call.returnType != TypeCategory::VOID)
       suffix = "  return result;\n" + suffix;
 
     if (call.returnType == TypeCategory::DEPENDENT_STRING ||
         call.returnType == TypeCategory::OWNED_STRING || hasStringArgs)
     {
       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;
   }
 
-  const std::string generatePropertyDescriptor(const PropertyInfo& property)

[sergei, 2016/06/16 21:16:56]

I'm not sure that we need the `const` for the return object.

[Wladimir Palant, 2016/12/06 10:48:05]

Done.

+  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));

[sergei, 2016/06/16 21:17:16]

What about ';' after "%i"?

[Wladimir Palant, 2016/12/06 10:48:07]

Done.

+    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);
     return length;
   }
 
   function createString(str)
   {
     var length = 0;
     var buffer = 0;
     if (str)
     {
       buffer = Runtime.stackAlloc(str.length * 2);
       length = copyString(str, buffer);
     }
 
     var result = Module.Runtime.stackAlloc(sizeofString);
     Module._InitString(result, buffer, length);
     return result;
   }
 
-  function getStringData(str)

[sergei, 2016/06/16 21:17:15]

What do you think about renaming of this method. Currently it looks like it
returns some pointer to the data of str but actually it returns a new JS string
object.

[Wladimir Palant, 2016/12/06 10:48:10]

Ok, readString() it is - hopefully more obvious.

+  function readString(str)
   {
     var length = Module._GetStringLength(str);
     var pointer = Module._GetStringData(str) >> 1;
     return String.fromCharCode.apply(String, HEAP16.slice(pointer, pointer + length));

[sergei, 2016/06/16 21:16:46]

Shouldn't we use fromCodePoint instead of fromCharCode here?

[Wladimir Palant, 2016/12/06 10:48:08]

No, we shouldn't - we are using 16-bit characters. Codepoints can be a
combination of multiple 16-bit characters.

   }
 
-  function createClass(superclass)
+  function createClass(superclass, ref_counted_offset)
   {
     var result = function(pointer)
     {
       this._pointer = pointer;

[sergei, 2016/06/16 21:17:11]

We should call Module._AddRef on stored _pointer here.

[Wladimir Palant, 2016/12/06 10:47:41]

No, we shouldn't - that's a raw pointer we got here, it should already be
addref'ed.

     };
     if (superclass)
       result.prototype = Object.create(superclass.prototype);
     result.prototype.delete = function()
     {
-      Module._ReleaseRef(this._pointer);
+      Module._ReleaseRef(this._pointer + ref_counted_offset);
     };
     return result;
   })");
   }
 
-  void printClass(ClassInfo& cls)
+  void printClass(const ClassInfo& cls)
   {
     DifferentiatorInfo differentiator = cls.subclass_differentiator;
-    if (!differentiator.call.empty())
+    if (differentiator.offset != SIZE_MAX)
     {
       printf("var %s_mapping = \n", cls.name.c_str());
       puts("{");
-      for (auto it = differentiator.mapping.begin(); it != differentiator.mapping.end(); ++it)
-        printf("  %i: '%s',\n", it->first, it->second.c_str());
+      for (const auto& item : differentiator.mapping)
+        printf("  %i: '%s',\n", item.first, item.second.c_str());
       puts("};");
     }
 
-    printf("exports.%s = createClass(%s);\n", cls.name.c_str(),
-        (cls.baseClass ? ("exports." + cls.baseClass->name).c_str() : ""));
-
-    for (auto it = cls.properties.begin(); it != cls.properties.end(); ++it)
+    printf("exports.%s = createClass(%s, %i);\n", cls.name.c_str(),
+        (cls.baseClass ? ("exports." + cls.baseClass->name).c_str() : "null"),
+        cls.ref_counted_offset);
+
+    for (const auto& item : cls.properties)
     {
       printf("Object.defineProperty(exports.%s.prototype, '%s', {%s});\n",
-          cls.name.c_str(), it->name.c_str(),
-          generatePropertyDescriptor(*it).c_str());
-    }
-
-    for (auto it = cls.methods.begin(); it != cls.methods.end(); ++it)
+          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 (it->call.instance_function)
+      if (item.call.instance_function)
         obj += ".prototype";
-      printf("%s.%s = %s;\n", obj.c_str(), it->name.c_str(),
-          wrapCall(it->call).c_str());
-    }
-
-    for (auto it = cls.initializers.begin(); it != cls.initializers.end(); ++it)
-      printf("%s()\n", it->name);
+      printf("%s.%s = %s;\n", obj.c_str(), item.name.c_str(),
+          wrapCall(item.call).c_str());
+    }
+
+    for (const auto& item : cls.initializers)
+      printf("%s()\n", item.name);
   }
 
   void printBindings()
   {
     printHelpers();
 
-    for (auto it = classes.begin(); it != classes.end(); ++it)
-      printClass(it->second);
+    for (const auto& item : classes)
+      printClass(item.second);
   }
 }
 
 #if defined(PRINT_BINDINGS)
   // Bindings generation step: collect bindings information and print
   // corresponding JS code.
   #define EMSCRIPTEN_BINDINGS \
-      static struct BindingsInitializer {\

[sergei, 2016/06/16 21:16:54]

I think static is not required here.

[Wladimir Palant, 2016/12/06 10:47:44]

Done.

+      struct BindingsInitializer {\
           BindingsInitializer();\
           BindingsInitializer(bool dummy)\
           {\
             try\
             {\
               BindingsInitializer();\
               bindings_internal::printBindings();\
             }\
             catch (const std::exception& e)\
             {\
@@ skipping 28 matching lines @@
         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 AddRef(ref_counted* ptr)\
-        {\
-          ptr->AddRef();\
-        }\
         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_
 {
 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>());
+        bindings_internal::TypeInfo<BaseClass>(),
+        ref_counted_offset
+      );
   }
 
   template<typename FieldType>
   const class_& property(const char* name,
       FieldType (ClassType::*getter)() const,
-      void (ClassType::*setter)(FieldType) = 0) const

[sergei, 2016/06/16 21:17:07]

I would rather use nullptr instead of 0.

[Wladimir Palant, 2016/12/06 10:47:50]

Done.

+      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(
@@ skipping 28 matching lines @@
   }
 
   const class_& class_initializer(void (*function)()) const
   {
     bindings_internal::register_initializer(
         bindings_internal::TypeInfo<ClassType>(), function);
     return *this;
   }
 
   template<typename ReturnType,
-      typename std::enable_if<std::is_convertible<ReturnType, int>::value>::type* = nullptr>
-  const class_& subclass_differentiator(ReturnType (*function)(ClassType*),
-      std::initializer_list<std::pair<ReturnType,const char*>> list) const

[sergei, 2016/06/16 21:17:04]

Just wonder, why are no spaces between types for std::pair?

[Wladimir Palant, 2016/12/06 10:47:54]

Done.

-  {
-    std::vector<std::pair<int,std::string>> mapping;
-    for (auto it = list.begin(); it != list.end(); ++it)
-      mapping.push_back(std::pair<int,std::string>(it->first, it->second));

[sergei, 2016/06/16 21:16:59]

Merely a shorter syntax, here and above we can use
for (const auto& item: container){}

so here it could be
for (const auto& item : list)
  mapping.emplace_back(item.first, item.second);

[Wladimir Palant, 2016/12/06 10:47:48]

Done.

+      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>(), function, mapping);
+        bindings_internal::TypeInfo<ClassType>(), offset, mapping);
     return *this;
   }
 };