Google Git
Sign in
bazel / crubit / a45d260ea45524ae25df3b3a78726097c939daaf
commita45d260ea45524ae25df3b3a78726097c939daaf[log] [tgz]
authorSam McCall <sammccall@google.com>Fri Apr 28 13:20:15 2023 -0700
committerCopybara-Service <copybara-worker@google.com>Fri Apr 28 13:21:09 2023 -0700
treee5c8de73e46209a4d42f07cb328c336c2575f063
parent70942e50c115c38e56adacabd6da2c9b8a01e8e9 [diff]
For classes nested in template classes, include outer tparams in nullability

Given `template <class T> struct X { struct Y {}; };`
Y can depend on T in the same ways that X can.
Therefore the nullability of T is part of Y's nullability too.

For now, there's no observable effect except that the nullability vectors are the right length, padded with Unspecified, but we're building towards nested template support.
 - when we walk up the redecl chain there is no sugar.
   My other patch will provide this in some cases ("Resugar substituted type params found in class template instantiations"), we need to look up the template args in the instantiation context.
 - we don't consume the outer class nullability anywhere. We will be able to do this around substituteNullabilityAnnotationsInClassTemplate, addressing TODOs about nested templates. This will require some restructuring as we don't actually whether the inner class is a template anymore.

PiperOrigin-RevId: 527969535
4 files changed
tree: e5c8de73e46209a4d42f07cb328c336c2575f063
  1. .bazelci/
  2. bazel/
  3. cc_bindings_from_rs/
  4. common/
  5. docs/
  6. lifetime_analysis/
  7. lifetime_annotations/
  8. migrator/
  9. nullability_verification/
  10. rs_bindings_from_cc/
  11. support/
  12. .bazelrc
  13. .gitignore
  14. BUILD
  15. Cargo.Bazel.lock
  16. CODE_OF_CONDUCT
  17. CONTRIBUTING
  18. LICENSE
  19. README.md
  20. WORKSPACE
README.md

Crubit: C++/Rust Bidirectional Interop Tool

Build status

Crubit is an experimental bidirectional bindings generator for C++ and Rust.

Please don‘t use, this is an experiment and we don’t yet know where will it take us. There will be breaking changes without warning. Unfortunately, we can't take contributions at this point.

Crubit allows for C++ code and Rust code to call each other without manually wrapping the APIs in an FFI-friendly interop layer. For example, a C++ function like this:

bool IsAbsPath(std::string_view path);

... becomes callable from Rust as if it were defined as:

pub fn IsAbsPath(path: std::string_view) -> bool {...}

Crubit automatically generates ABI-compatible bindings for structs (which can be passed both by value and by reference), functions, and methods, for a large variety of types. (Trivial types, nontrivial types, templated types, etc.)

Building Crubit

$ apt install clang lld bazel
$ git clone git@github.com:google/crubit.git
$ cd crubit
$ bazel build --linkopt=-fuse-ld=/usr/bin/ld.lld //rs_bindings_from_cc:rs_bindings_from_cc_impl

Using a prebuilt LLVM tree

$ git clone https://github.com/llvm/llvm-project
$ cd llvm-project
$ CC=clang CXX=clang++ cmake -S llvm -B build -DLLVM_ENABLE_PROJECTS='clang' -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=install
$ cmake --build build -j
$ # wait...
$ cmake --install build
$ cd ../crubit
$ LLVM_INSTALL_PATH=../llvm-project/install bazel build //rs_bindings_from_cc:rs_bindings_from_cc_impl