Make templated C++ types useful

[adetaylor]

Split off from #106. At the moment, a templated C++ type gets made into a completely opaque type called AutocxxConcrete0...n. These types don't have constructors, accessors, or methods, so are useless except as an opaque token passed from C++, through Rust, back into C++.

Options are:

• Make cxx accept templated types, as mentioned in Dependent qualified types don't work #106 (comment) and Functions and opaque types with type parameters dtolnay/cxx#767
• Alternatively (far less preferably) add constructors, methods and accessors to these types to make them actually useful.

[koutheir]

The LLVM C++ API defines a class called ErrorOr<T> whose semantics resemble the Rust Result struct. ErrorOr<T> is used by many functions as return value, and due to this, all those functions cannot be used through autocxx. An example of this is llvm::MemoryBuffer::getFile():

// Inside class MemoryBuffer

static ErrorOr<std::unique_ptr<MemoryBuffer>>
getFile(const Twine &Filename,
        bool IsText = false,
        bool RequiresNullTerminator = true,
        bool IsVolatile = false);

I read the documentation, but I couldn't figure out the recommended way to deal with this situation. @adetaylor, can you advise on how I should fix this issue in order to use these functions?

[adetaylor]

Yeah, per this bug they're just opaque from Rust.

The workaround is to define new C++ functions like this, to let you unpack the error.

bool IsAnError(ErrorOr<std::unique_ptr<MemoryBuffer>>) {
  // ...
}

std::unique_ptr<MemoryBuffer> UnpackSuccessValue(ErrorOr<std::unique_ptr<MemoryBuffer>>) {
  // unpack and return the thing
}

Ask autocxx to generate bindings for those. Whenever you call any function which gives you the pesky ErrorOr<std::unique_ptr<T>>, you can pass it into those functions to get out some useful information.

This is not ideal, of course. That's why this bug exists.

[koutheir]

It looks like, due to the issue of ErrorOr<T>, the method llvm::MemoryBuffer::getFile() is generated as follows:

#[doc = "autocxx bindings couldn't be generated: This function or method uses a type where one of the template parameters was incomprehensible to bindgen/autocxx - probably because it uses template specialization."]
fn getFile(_uhoh: autocxx::BindingGenerationFailure) {}

How should I convince autocxx to generate that method with an opaque type (e.g., ErrorOrUniquePtrMemoryBuffer) that I could then pass to custom functions like the above IsAnError()?

[adetaylor]

Oh, I see.

Unfortunately that's currently not possible. But, I just raised #1009 as a future enhancement to make that possible. I'll try to look into it sometime in the next few weeks (no promises at all.)