Add support for overloading class member functions and class static functions based on function argument count.

2 files changed, 149 insertions, 0 deletions

diff --git a/tests/embind/embind.test.js b/tests/embind/embind.test.js
index 11746214..020719d5 100755
--- a/tests/embind/embind.test.js
+++ b/tests/embind/embind.test.js
@@ -620,6 +620,62 @@ module({
             assert.throws(cm.BindingError, function() { cm.overloaded_function(30, 30, 30); });
         });
 
+        test("overloading of class member functions", function() {
+            var foo = new cm.MultipleOverloads();
+            assert.equal(foo.Func(10), 1);
+            assert.equal(foo.WhichFuncCalled(), 1);
+            assert.equal(foo.Func(20, 20), 2);
+            assert.equal(foo.WhichFuncCalled(), 2);
+            foo.delete();
+        });
+
+        test("wrong number of arguments to an overloaded class member function", function() {
+            var foo = new cm.MultipleOverloads();
+            assert.throws(cm.BindingError, function() { foo.Func(); });
+            assert.throws(cm.BindingError, function() { foo.Func(30, 30, 30); });
+            foo.delete();
+        });
+
+        test("wrong number of arguments to an overloaded class static function", function() {
+            assert.throws(cm.BindingError, function() { cm.MultipleOverloads.StaticFunc(); });
+            assert.throws(cm.BindingError, function() { cm.MultipleOverloads.StaticFunc(30, 30, 30); });
+        });
+
+        test("overloading of derived class member functions", function() {
+            var foo = new cm.MultipleOverloadsDerived();
+            
+            // NOTE: In C++, default lookup rules will hide overloads from base class if derived class creates them.
+            // In JS, we make the base class overloads implicitly available. In C++, they would need to be explicitly
+            // invoked, like foo.MultipleOverloads::Func(10);
+            assert.equal(foo.Func(10), 1);
+            assert.equal(foo.WhichFuncCalled(), 1);
+            assert.equal(foo.Func(20, 20), 2);
+            assert.equal(foo.WhichFuncCalled(), 2);
+
+            assert.equal(foo.Func(30, 30, 30), 3);
+            assert.equal(foo.WhichFuncCalled(), 3);
+            assert.equal(foo.Func(40, 40, 40, 40), 4);
+            assert.equal(foo.WhichFuncCalled(), 4);
+            foo.delete();
+        });
+        
+        test("overloading of class static functions", function() {
+            assert.equal(cm.MultipleOverloads.StaticFunc(10), 1);
+            assert.equal(cm.MultipleOverloads.WhichStaticFuncCalled(), 1);
+            assert.equal(cm.MultipleOverloads.StaticFunc(20, 20), 2);
+            assert.equal(cm.MultipleOverloads.WhichStaticFuncCalled(), 2);
+        });
+
+        test("overloading of derived class static functions", function() {
+            assert.equal(cm.MultipleOverloadsDerived.StaticFunc(30, 30, 30), 3);
+            // TODO: Cannot access static member functions of a Base class via Derived.
+//            assert.equal(cm.MultipleOverloadsDerived.WhichStaticFuncCalled(), 3);
+            assert.equal(cm.MultipleOverloads.WhichStaticFuncCalled(), 3);
+            assert.equal(cm.MultipleOverloadsDerived.StaticFunc(40, 40, 40, 40), 4);
+            // TODO: Cannot access static member functions of a Base class via Derived.
+//            assert.equal(cm.MultipleOverloadsDerived.WhichStaticFuncCalled(), 4);
+            assert.equal(cm.MultipleOverloads.WhichStaticFuncCalled(), 4);
+        });
 /*
         test("can get templated member classes then call its member functions", function() {
             var p = new cm.ContainsTemplatedMemberClass();
diff --git a/tests/embind/embind_test.cpp b/tests/embind/embind_test.cpp
index be089f9f..1ef3fb16 100644
--- a/tests/embind/embind_test.cpp
+++ b/tests/embind/embind_test.cpp
@@ -1339,6 +1339,83 @@ public:
     }

 };

 

+class MultipleOverloads {

+public:

+    MultipleOverloads() {}

+    

+    int value;

+    static int staticValue;

+    

+    int Func(int i) {

+        assert(i == 10);

+        value = 1;

+        return 1;

+    }

+    int Func(int i, int j) {

+        assert(i == 20);

+        assert(j == 20);

+        value = 2;

+        return 2;

+    }

+

+    int WhichFuncCalled() const {

+        return value;

+    }

+    

+    static int StaticFunc(int i) {

+        assert(i == 10);

+        staticValue = 1;

+        return 1;

+    }

+    static int StaticFunc(int i, int j) {

+        assert(i == 20);

+        assert(j == 20);

+        staticValue = 2;

+        return 2;

+    }

+

+    static int WhichStaticFuncCalled() {

+        return staticValue;

+    }

+};

+

+class MultipleOverloadsDerived : public MultipleOverloads {

+public:

+    MultipleOverloadsDerived() {}

+        

+    int Func(int i, int j, int k) {

+        assert(i == 30);

+        assert(j == 30);

+        assert(k == 30);

+        value = 3;

+        return 3;

+    }

+    int Func(int i, int j, int k, int l) {

+        assert(i == 40);

+        assert(j == 40);

+        assert(k == 40);

+        assert(l == 40);

+        value = 4;

+        return 4;

+    }

+    

+    static int StaticFunc(int i, int j, int k) {

+        assert(i == 30);

+        assert(j == 30);

+        assert(k == 30);

+        staticValue = 3;

+        return 3;

+    }

+    static int StaticFunc(int i, int j, int k, int l) {

+        assert(i == 40);

+        assert(j == 40);

+        assert(k == 40);

+        assert(l == 40);

+        staticValue = 4;

+        return 4;

+    }

+};

+

 int overloaded_function(int i)

 {

     assert(i == 10);

@@ -1823,6 +1900,22 @@ EMSCRIPTEN_BINDINGS(tests) {
         .constructor<int, int>()

         .constructor<int, int, int>()

         .function("WhichCtorCalled", &MultipleCtors::WhichCtorCalled);

+        

+    class_<MultipleOverloads>("MultipleOverloads")

+        .constructor<>()

+        .function("Func", (int(MultipleOverloads::*)(int))&MultipleOverloads::Func)

+        .function("Func", (int(MultipleOverloads::*)(int,int))&MultipleOverloads::Func)

+        .function("WhichFuncCalled", &MultipleOverloads::WhichFuncCalled)

+        .class_function("StaticFunc", (int(*)(int))&MultipleOverloads::StaticFunc)

+        .class_function("StaticFunc", (int(*)(int,int))&MultipleOverloads::StaticFunc)

+        .class_function("WhichStaticFuncCalled", &MultipleOverloads::WhichStaticFuncCalled);

+

+    class_<MultipleOverloadsDerived, base<MultipleOverloads> >("MultipleOverloadsDerived")

+        .constructor<>()

+        .function("Func", (int(MultipleOverloadsDerived::*)(int,int,int))&MultipleOverloadsDerived::Func)

+        .function("Func", (int(MultipleOverloadsDerived::*)(int,int,int,int))&MultipleOverloadsDerived::Func)

+        .class_function("StaticFunc", (int(*)(int,int,int))&MultipleOverloadsDerived::StaticFunc)

+        .class_function("StaticFunc", (int(*)(int,int,int,int))&MultipleOverloadsDerived::StaticFunc);

 }

 

 // tests for out-of-order registration