5 Commits

Include renames

Author	SHA1	Message	Date
Richard Smith	a6acba9eab	Support for importing const-qualified types from C++. (#5794) ... Incidentally also supports import of pointers-to-pointers. Imported const-qualified types aren't especially useful just yet, because on the Carbon side we don't yet permit conversions from non-const to const types, so most of the tests still fail, but for different reasons now.	2025-07-12 02:22:24 +00:00
Jon Ross-Perkins	8cd1307711	Include the interface name in impl names (#5798) ... i.e., `impl` -> `<interface>.impl`	2025-07-11 19:52:53 +00:00
Jon Ross-Perkins	e855f38b8c	Tag destruction as desugaring (#5790) ... In `BuildUnaryOperator`, `GetOperatorOpFunction` is treated as desugaring, but `PerformCompoundMemberAccess` and `PerformCall` are not. This treats all of destruction as desugaring. This leads to some instructions being elided, because of `GetOrAddInst` behaviors: > // If the instruction has a desugared location and a constant value, returns > // the constant value's instruction ID. Otherwise, same as AddInst. This changes instructions that previously had a non-desugared location to instead have a desugared location, so if they also have a constant value then the constant value can be used directly.	2025-07-10 21:21:19 +00:00
Richard Smith	26e23eac10	Support import of typedefs. (#5787) ... Unify code paths for importing classes by name and importing them indirectly when their type is referenced. Switch to using the general type import machinery to import all type declarations, which allows typedef declarations naming importable types to be used too. Fix up handling of error cases to consistently only produce an Error InstId after actually producing an error message, so that we can produce exactly one diagnostic in failure cases. Remove TODO error for unions that previously was only produced when importing them indirectly, not when importing them by name. Import of unions is exactly as complete / incomplete as import of other class types, so treating them differently doesn't seem necessary.	2025-07-10 20:46:46 +00:00
Boaz Brickner	a5ddc3e3cd	Support importing C++ _Nonnull pointers as function parameters or return values (#5773) ... We avoid using canonical type before knowing it's not a pointer because we need the nullability attribute. No support for pointers to pointers, yet. C++ Interop Demo: ```c++ // hello_world.h auto hello_world_param(int* _Nonnull i) -> void; auto hello_world_return() -> int* _Nonnull; ``` ```c++ // hello_world.cpp #include "hello_world.h" #include <cstdio> auto hello_world_param(int* _Nonnull i) -> void { printf("hello_world: %d\n", *i); } static int x = 5; auto hello_world_return() -> int* _Nonnull { return &x; } ``` ```carbon // main.carbon library "Main"; import Core library "io"; import Cpp library "hello_world.h"; fn Run() -> i32 { var i: i32 = 10; Cpp.hello_world_param(&i); let p: i32* = Cpp.hello_world_return(); Core.Print(*p); return 0; } ``` ```shell $ clang -c hello_world.cpp $ ./bazel-bin/toolchain/install/prefix_root/bin/carbon compile main.carbon $ ./bazel-bin/toolchain/install/prefix_root/bin/carbon link hello_world.o main.o --output=demo $ ./demo hello_world: 10 5 ``` Part of #5772.	2025-07-10 08:00:37 +00:00