carbon-lang

4,442 Commits 3 Branches 813 Tags

2 Commits

Include renames

Author SHA1 Message Date

Author	SHA1	Message	Date
Jon Ross-Perkins	9704dc670e	Change the Destroy blanket impls to be more specific (#6098 ) The main direction of this change is the edits to `destroy.carbon` (matching in both prelude and min_prelude). Previously there was a no-op blanket impl for `Destroy`, which hid all missing implementations of `Destroy`. This does a few things: - Sets up builtin aggregate destruction for struct and tuple types as before, but also adds C++ class types and array types to the same handling. (all as a TODO for actual implementation) - Also maybe-unformed destruction, for now at least. (there's a chance I may try a different approach on this, but the impl lookup wasn't working as I'd hope in order to write it in code) - Adds handlers for simple things that are easy to do in code: `type`, `bool`, pointers. (because these are no-op destruction) - Redirect `const T` destruction to `T` destruction. This leaves as future issues: - `partial T` destruction. (this can't be done similar to `const` because it only works for non-`final` class types; I think `class` definitions should just generate what's needed) - Destruction of other prelude-provided types. (will probably come up as we implement class destruction, that the adapted builtin type doesn't implement `Destroy` -- but may end up special-casing that in a way that moots it) This moves the `&` operator from `facet_types.carbon` to `convert.carbon` because more things need to handle type and now that we're getting separate copy and destroy interfaces. It should be low-cost (an interface and builtin) so hopefully this is the right balance for complexity and re-use. A few tests are also edited in order to focus them more on what they intend to test, and avoid a `Destroy` dependency.	2025-09-18 22:10:50 +00:00
Boaz Brickner	9b35640a31	C++ interop: Add `Cpp.<builtin_type>` (#6047 ) Based on proposal #5448. Defining all `Cpp.<builtin_type>` names. Still unsupported types on LP64: `long long`, `unsigned long long` and `long double`. Still unsupported types on LLP64: `long`, `unsigned long` and `long double`. C++ Interop Demo (on LP64): ```c++ // half.h auto Half(long x) -> float; auto PrintLong(long x) -> void; auto PrintFloat(float x) -> void; ``` ```c++ // half.cpp #include <cstdio> auto Half(long x) -> float { return static_cast<float>(x) / 2; } auto PrintLong(long x) -> void { printf("%ld\n", x); } auto PrintFloat(float x) -> void { printf("%f\n", x); } ``` ```carbon // main.carbon library "Main"; import Cpp library "half.h"; fn Run() -> i32 { let x: Cpp.long = 5; Cpp.PrintLong(x); let y: Cpp.float = Cpp.Half(x); Cpp.PrintFloat(y); return 0; } ``` ```shell $ clang -c half.cpp $ bazel-bin/toolchain/carbon compile main.carbon $ bazel-bin/toolchain/carbon link half.o main.o --output=demo $ ./demo 5 2.500000 ``` Part of #5263.	2025-09-16 09:29:10 +00:00

9704dc670e

Change the Destroy blanket impls to be more specific (#6098 )

The main direction of this change is the edits to `destroy.carbon`
(matching in both prelude and min_prelude).

Previously there was a no-op blanket impl for `Destroy`, which hid all
missing implementations of `Destroy`. This does a few things:

- Sets up builtin aggregate destruction for struct and tuple types as
before, but also adds C++ class types and array types to the same
handling. (all as a TODO for actual implementation)
- Also maybe-unformed destruction, for now at least. (there's a chance I
may try a different approach on this, but the impl lookup wasn't working
as I'd hope in order to write it in code)
- Adds handlers for simple things that are easy to do in code: `type`,
`bool`, pointers. (because these are no-op destruction)
- Redirect `const T` destruction to `T` destruction.

This leaves as future issues:

- `partial T` destruction. (this can't be done similar to `const`
because it only works for non-`final` class types; I think `class`
definitions should just generate what's needed)
- Destruction of other prelude-provided types. (will probably come up as
we implement class destruction, that the adapted builtin type doesn't
implement `Destroy` -- but may end up special-casing that in a way that
moots it)

This moves the `&` operator from `facet_types.carbon` to
`convert.carbon` because more things need to handle type and now that
we're getting separate copy and destroy interfaces. It should be
low-cost (an interface and builtin) so hopefully this is the right
balance for complexity and re-use.

A few tests are also edited in order to focus them more on what they
intend to test, and avoid a `Destroy` dependency.

2025-09-18 22:10:50 +00:00

Boaz Brickner

9b35640a31

C++ interop: Add Cpp.<builtin_type> (#6047 )

Based on proposal #5448.

Defining all `Cpp.<builtin_type>` names.
Still unsupported types on LP64: `long long`, `unsigned long long` and
`long double`.
Still unsupported types on LLP64: `long`, `unsigned long` and `long
double`.

C++ Interop Demo (on LP64):

```c++
// half.h

auto Half(long x) -> float;
auto PrintLong(long x) -> void;
auto PrintFloat(float x) -> void;
```

```c++
// half.cpp

#include <cstdio>

auto Half(long x) -> float {
  return static_cast<float>(x) / 2;
}

auto PrintLong(long x) -> void {
  printf("%ld\n", x);
}

auto PrintFloat(float x) -> void {
  printf("%f\n", x);
}
```

```carbon
// main.carbon

library "Main";

import Cpp library "half.h";

fn Run() -> i32 {
  let x: Cpp.long = 5;
  Cpp.PrintLong(x);
  let y: Cpp.float = Cpp.Half(x);
  Cpp.PrintFloat(y);
  return 0;
}
```

```shell
$ clang -c half.cpp
$ bazel-bin/toolchain/carbon compile main.carbon
$ bazel-bin/toolchain/carbon link half.o main.o --output=demo
$ ./demo
5
2.500000
```

Part of #5263.

2025-09-16 09:29:10 +00:00