1.0.1

• Fix ability to use an extern enum (https://cxx.rs/shared.html#extern-enums) as a field of a shared struct (#490)
• Allow shared enums to contain multiple discriminants with the same integer value, relaxing a restriction that C++ does not have (#492)
• Add impl DerefMut for UniquePtr<T> as long as T is a shared struct, not an opaque C++ type (#493)

1.0.0

Breaking changes

• extern "C" extern block in the FFI module is no longer accepted, write extern "C++" instead
• extern "C++" block must be written unsafe extern "C++" if it contains at least one safe-to-call function
• rust::Slice<T> in C++ has been renamed to rust::Slice<const T>; support for &mut [T] post-1.0 will use the rust::Slice<T> name
• &mut T where T is an opaque C++ type is no longer ever exposed to Rust, only Pin<&mut T>
• Related to the previous: UniquePtr binding no longer implements DerefMut for opaque C++ types
• If a function's implementation is unsafe in Rust, extern "Rust" block will enforce that it's listed as unsafe fn in the extern block too
• Opaque Rust types are required to be Unpin in addition to Sized
• Opaque Rust types are required to be local to the current crate (for now; this may soon be lifted again)
• Handwritten Unpin impl for opaque C++ types are ruled out
• Minimum supported rustc version is raised from 1.43 to 1.48

0.5.10

• Fix missing cstdint import when generating enums (#477)

0.5.9

• Add the following member functions on rust::Vec<T> in C++, matching the API of std::vector:

  void reserve(size_t new_cap); 
  
  void push_back(const T &value); 
  void push_back(T &&value); 
  
  template <typename... Args> 
  void emplace_back(Args &&... args); 

0.5.8

• Support #[namespace = "..."] attribute on extern blocks (#444)

  An item will inherit the namespace specified on its surrounding extern block if any, otherwise the namespace specified with the top level cxx::bridge attribute.

  #[cxx::bridge(namespace = "third_priority")]
  mod ffi {
      #[namespace = "second_priority"]
      extern "Rust" {
          fn f();
  
          #[namespace = "first_priority"]
          fn g();
      }
  
      extern "Rust" {
          fn h();
      }
  }

  The above would result in functions ::second_priority::f, ::first_priority::g, ::third_priority::h.

0.5.7

• Fix non-compilable C++ code generated when a no-argument method returns String (#442)

0.5.6

• Support methods/member functions on shared structs (#376)

0.5.5

• Introduce a mechanism to publicly export headers from a dependency in Cargo-based builds (#417)
  See the documentation of:
  • CFG.exported_header_dirs
  • CFG.exported_header_prefixes
  • CFG.exported_header_links

0.5.4

• Fix no template named 'impl' error in modules containing a reference to &[u8] but no reference to Result

0.5.3

• Add an item-level #[namespace = "..."] attribute to specify the C++ namespace path of an individual type or function (#370, #380, thanks @adetaylor)

  #[cxx::bridge]
  mod ffi {
      #[namespace = "the::path::of"]
      struct Thing {...}
  
      extern "C++" {
          #[namespace = "some::where::else"]
          fn function() -> Thing;
      }
  }

• Emit diagnostic on include! paths relative to . or .., as the positioning of generated code inside of Cargo's OUT_DIR is not specified (#368, #375)

• Treat C++ constructors rust::String(nullptr, 0) and rust::Str(nullptr, 0) as creating empty strings; previously UB (#383)

• Enable rust::Str and rust::Slice<T> to be passed in registers by C++ (#387)

• Eliminate warning from rustc 1.46+ when using function pointers in the signature of an extern C++ function (#396)

• Support single Rust source file containing multiple #[cxx::bridge] modules (#397)

• Expose a way to bypass is_trivially_destructible/_move_constructible check on extern types passed by value (#406)

  // IsRelocatable<T> is used in assertions that a C++ type passed by value
  // between Rust and C++ is soundly relocatable by Rust.
  //
  // There may be legitimate reasons to opt out of the check for support of types
  // that the programmer knows are soundly Rust-movable despite not being
  // recognized as such by the C++ type system due to a move constructor or
  // destructor. To opt out of the relocatability check, do either of the
  // following things in any header used by `include!` in the bridge.
  //
  //      --- if you define the type:
  //      struct MyType {
  //        ...
  //    +   using IsRelocatable = std::true_type;
  //      };
  //
  //      --- otherwise:
  //    + template <>
  //    + struct rust::IsRelocatable<MyType> : std::true_type {};
  template <typename T>
  struct IsRelocatable;

• Fix error on pass-by-reference of a shared struct containing a Rust String to a C++ function (#408)

• Make shared structs order-independent such that a struct is able to contain a field whose type is another shared struct defined later in the same FFI module (#411)