• Implement translation between Rust [T; N] and C std::array<T, N> (#503)

• Support &mut [u8] (spelled rust::Slice<uint8_t> in C ) in extern function arguments and returns (#502)

• Support shared enums without any explicitly declared variants as long as they are provided a defined repr (#494)

  #[cxx::bridge]
  mod ffi {
      #[repr(i32)]
      enum SharedEnum {}
  }

• 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)

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

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

• 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); 

• 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.

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

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