checkpoint returning JS instances out of embind

3 files changed, 43 insertions, 2 deletions

diff --git a/src/embind/embind.js b/src/embind/embind.js
index 536d53fc..25c3191a 100644
--- a/src/embind/embind.js
+++ b/src/embind/embind.js
@@ -1757,7 +1757,9 @@ function __embind_create_inheriting_constructor(constructorName, wrapperType, pr
             }
         }.bind(this));
 
-        this.__parent = wrapperPrototype;
+        Object.defineProperty(this, '__parent', {
+            value: wrapperPrototype
+        });
         this.initialize.apply(this, arraySlice.call(arguments));
     });
 
@@ -1766,7 +1768,9 @@ function __embind_create_inheriting_constructor(constructorName, wrapperType, pr
         var inner = baseConstructor.__$implement.apply(
             undefined,
             [this].concat(arraySlice.call(arguments)));
-        this.$$ = inner.$$;
+        Object.defineProperty(this, '$$', {
+            value: inner.$$
+        });
     };
 
     ctor.prototype = Object.create(wrapperPrototype);
diff --git a/tests/embind/embind.test.js b/tests/embind/embind.test.js
index 6f0c6860..2c274014 100644
--- a/tests/embind/embind.test.js
+++ b/tests/embind/embind.test.js
@@ -1767,6 +1767,21 @@ module({
 
             assert.equal("hi", rv);
         });
+
+/* does not pass yet
+        test("if JavaScript implementation of interface is returned, don't wrap in new handle", function() {
+            var parent = cm.HeldAbstractClass;
+            var C = parent.extend("C", {
+                method: function() {
+                }
+            });
+            var impl = new C;
+            var rv = cm.passHeldAbstractClass(impl);
+            assert.equal(impl, rv);
+
+            impl.delete();
+        });
+*/
     });
 
     BaseFixture.extend("registration order", function() {
diff --git a/tests/embind/embind_test.cpp b/tests/embind/embind_test.cpp
index d652d528..d7999b6f 100644
--- a/tests/embind/embind_test.cpp
+++ b/tests/embind/embind_test.cpp
@@ -1181,6 +1181,21 @@ std::string callAbstractMethod2(AbstractClassWithConstructor& ac) {
     return ac.abstractMethod();
 }
 
+struct HeldAbstractClass {
+    virtual void method() = 0;
+};
+struct HeldAbstractClassWrapper : wrapper<HeldAbstractClass> {
+    EMSCRIPTEN_WRAPPER(HeldAbstractClassWrapper);
+
+    virtual void method() override {
+        return call<void>("method");
+    }
+};
+
+std::shared_ptr<HeldAbstractClass> passHeldAbstractClass(std::shared_ptr<HeldAbstractClass> p) {
+    return p;
+}
+
 EMSCRIPTEN_BINDINGS(interface_tests) {
     class_<AbstractClass>("AbstractClass")
         .smart_ptr<std::shared_ptr<AbstractClass>>("shared_ptr<AbstractClass>")
@@ -1208,6 +1223,13 @@ EMSCRIPTEN_BINDINGS(interface_tests) {
         .function("concreteMethod", &AbstractClassWithConstructor::concreteMethod)
         ;
     function("callAbstractMethod2", &callAbstractMethod2);
+
+    class_<HeldAbstractClass>("HeldAbstractClass")
+        .smart_ptr<std::shared_ptr<HeldAbstractClass>>("shared_ptr<HeldAbstractClass>")
+        .allow_subclass<HeldAbstractClassWrapper, std::shared_ptr<HeldAbstractClassWrapper>>("HeldAbstractClassWrapper")
+        .function("method", &HeldAbstractClass::method, pure_virtual())
+        ;
+    function("passHeldAbstractClass", &passHeldAbstractClass);
 }
 
 template<typename T, size_t sizeOfArray>