Support Arc<Self> ?

[arrtchiu]

Title of issue #20 suggests this was fixed but I can't seem to get it to work or find it in your test cases :)

foreign_class!(class Foo {
    self_type Foo;
    constructor Foo::new() -> Arc<Foo>;
    fn bar(self: Arc<Self>); // Error: `self` is only valid as the first argument of an associated function
    fn bar2(self: Arc<Foo>); // Error: `self` is only valid as the first argument of an associated function
});

[Dushistov]

This should work,
the idea of "constructor return type" and "self_type" is that rust_swig automatically handle constructor type -> self type conversation.

use std::sync::Arc;
pub struct Foo1;
impl Foo1 {
    fn bar(&self) {}
    fn bar2(&self) {}
}

foreign_class!(class Foo1 {
    self_type Foo1;
    constructor Foo1::new() -> Arc<Foo1> {
        Arc::new(Foo1)
    }
    fn Foo1::bar(&self);
    fn Foo1::bar2(&self);
});

[arrtchiu]

Sorry I didn't do a very good example. My issue is when I'm trying to have the actual Rust Foo take an Arc<Self> like this:

struct Foo;
impl Foo {
    // this fn needs to be able to copy a strong ref to itself
    fn bar_by_arc(self: Arc<Self>) {}
}

foreign_class!(class Foo {
    // ...
    // none of these work:
    fn Foo::bar_by_arc(&self);
    fn Foo::bar_by_arc(self: Arc<Self>);
});

Obviously one workaround is to do it with a free function:

fn bar_by_arc(foo: Arc<Foo>) {
    // logic that would go inside foo::bar_by_arc in here instead
}

related: https://stackoverflow.com/a/25463033

[arrtchiu]

Workaround is a little stranger actually, because on C++ side it wants to consume Foo when you call bar_by_arc:

Foo f;
Foo::bar_by_arc(f); // error: copy ctor is deleted

Instead I return a new Arc<Foo>:

foreign_class!(class Foo {
    fn bar_by_arc(foo: &Arc<Foo>) -> Arc<Foo> {
        // keep a copy for returning
        let ret_foo = Arc::clone(&foo);

        // copy the ref so Foo can work with it
        let foo = Arc::clone(&foo);
        foo.bar_by_arc();

        ret_foo
    }
})

Then on C++ side:

Foo f;
f = Foo::bar_by_arc(std::move(f));
// now i can keep my `f`

[Dushistov]

1. Any kind of fn method(self, where self should be passed "by value" is impossible to
   implement for other languages, so I lean to just report error for this during macros parsing.
   This is because none of languages that I know except Rust support such semantic, and foreign_class! is the way to describe how your class will look like for other language.
   So I lean to error reporting instead of automatically convert such code into "static member function"

2. There is syntax especially for this, but it wasn't implemented for C++, for now it was implemented only for Java, see https://github.com/Dushistov/rust_swig/blob/56601b07c05ac0b2aaf8285212f039939c17ee64/jni_tests/src/java_glue.rs.in#L1001
   If you pass around "class" marked as SmartPtrCopy it will be "copied" (just usage counter will be incremented) instead of "moved".