mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-27 21:20:09 +01:00
1dbf000905f2b2ff80f8ea51c1930c6d896fcf61
4
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Boaz Brickner
|
471b394c6d |
C++ interop: Support unary operators (#6020)
Newly supported: `-`.
Partially supported due to lack of reference support: `++` (prefix),
`--` (prefix).
Not supported due to lack of Carbon support to call them correctly: `+`,
`++` (postfix), `--` (postfix), `~`, `!`, `&`, `*`, `->`.
Also (for consistency):
* Add the operator declarations to unsupported binary operators tests.
* Logical operators and the unary `operator&` (address of) are expected
to be called by explicitly calling `operatorX`.
C++ Interop Demo:
```c++
// my_number.h
class MyNumber {
public:
explicit MyNumber(int value) : value_(value) {}
auto value() const -> int { return value_; }
private:
int value_;
};
auto operator++(MyNumber operand) -> MyNumber;
auto operator--(MyNumber operand) -> MyNumber;
auto operator-(MyNumber operand) -> MyNumber;
```
```c++
// my_number.cpp
#include "my_number.h"
auto operator++(MyNumber operand) -> MyNumber {
return MyNumber(operand.value() + 1);
}
auto operator--(MyNumber operand) -> MyNumber {
return MyNumber(operand.value() - 1);
}
auto operator-(MyNumber operand) -> MyNumber {
return MyNumber(-operand.value());
}
```
```carbon
// main.carbon
library "Main";
import Core library "io";
import Cpp library "my_number.h";
fn Run() -> i32 {
var num: Cpp.MyNumber = Cpp.MyNumber.MyNumber(14);
Core.Print(num.value());
++num;
Core.Print(num.value());
--num;
Core.Print(num.value());
num = -num;
Core.Print(num.value());
return 0;
}
```
```shell
$ clang -c my_number.cpp
$ bazel-bin/toolchain/carbon compile main.carbon
$ bazel-bin/toolchain/carbon link my_number.o main.o --output=demo
$ ./demo
14
14
14
-14
```
Part of https://github.com/carbon-language/carbon-lang/issues/5995.
|
||
|
Boaz Brickner
|
ee42b2db93 |
C++ interop: Support more binary operators (#6017)
Already supported: `+`.
Newly supported: `-`, `*`, `/`, `%`, `&`, `|`, `^`, `<<`, `>>`, `==`,
`!=`, `<`, `>`, `<=`, `>=`.
Partially supported due to lack of reference support: `+=`, `-=`, `*=`,
`/=`, `%=`, `&=`, `|=`, `^=`.
Not supported due to lack of reference support: `<<=`, `>>=`.
Not supported (I think Carbon doesn't want overloading these): `&&`,
`||`.
C++ Interop Demo:
```c++
// my_number.h
class MyNumber {
public:
explicit MyNumber(int value) : value_(value) {}
auto value() const -> int { return value_; }
void set_value(int value) { value_ = value; }
private:
int value_;
};
// Arithmetic
auto operator+(MyNumber lhs, MyNumber rhs) -> MyNumber;
auto operator-(MyNumber lhs, MyNumber rhs) -> MyNumber;
auto operator*(MyNumber lhs, MyNumber rhs) -> MyNumber;
auto operator/(MyNumber lhs, MyNumber rhs) -> MyNumber;
auto operator%(MyNumber lhs, MyNumber rhs) -> MyNumber;
// Bitwise
auto operator&(MyNumber lhs, MyNumber rhs) -> MyNumber;
auto operator|(MyNumber lhs, MyNumber rhs) -> MyNumber;
auto operator^(MyNumber lhs, MyNumber rhs) -> MyNumber;
auto operator<<(MyNumber lhs, int shift) -> MyNumber;
auto operator>>(MyNumber lhs, int shift) -> MyNumber;
// Compound Arithmetic
auto operator+=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull;
auto operator-=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull;
auto operator*=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull;
auto operator/=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull;
auto operator%=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull;
// Compound Bitwise
auto operator&=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull;
auto operator|=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull;
auto operator^=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull;
// Relational
auto operator==(MyNumber lhs, MyNumber rhs) -> bool;
auto operator!=(MyNumber lhs, MyNumber rhs) -> bool;
auto operator<(MyNumber lhs, MyNumber rhs) -> bool;
auto operator>(MyNumber lhs, MyNumber rhs) -> bool;
auto operator<=(MyNumber lhs, MyNumber rhs) -> bool;
auto operator>=(MyNumber lhs, MyNumber rhs) -> bool;
```
```c++
// my_number.cpp
#include "my_number.h"
// Arithmetic
auto operator+(MyNumber lhs, MyNumber rhs) -> MyNumber {
return MyNumber(lhs.value() + rhs.value());
}
auto operator-(MyNumber lhs, MyNumber rhs) -> MyNumber {
return MyNumber(lhs.value() - rhs.value());
}
auto operator*(MyNumber lhs, MyNumber rhs) -> MyNumber {
return MyNumber(lhs.value() * rhs.value());
}
auto operator/(MyNumber lhs, MyNumber rhs) -> MyNumber {
return MyNumber(lhs.value() / rhs.value());
}
auto operator%(MyNumber lhs, MyNumber rhs) -> MyNumber {
return MyNumber(lhs.value() % rhs.value());
}
// Bitwise
auto operator&(MyNumber lhs, MyNumber rhs) -> MyNumber {
return MyNumber(lhs.value() & rhs.value());
}
auto operator|(MyNumber lhs, MyNumber rhs) -> MyNumber {
return MyNumber(lhs.value() | rhs.value());
}
auto operator^(MyNumber lhs, MyNumber rhs) -> MyNumber {
return MyNumber(lhs.value() ^ rhs.value());
}
auto operator<<(MyNumber lhs, int shift) -> MyNumber {
return MyNumber(lhs.value() << shift);
}
auto operator>>(MyNumber lhs, int shift) -> MyNumber {
return MyNumber(lhs.value() >> shift);
}
// Compound Arithmetic
auto operator+=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull {
return &(*lhs = *lhs + rhs);
}
auto operator-=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull {
return &(*lhs = *lhs - rhs);
}
auto operator*=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull {
return &(*lhs = *lhs * rhs);
}
auto operator/=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull {
return &(*lhs = *lhs / rhs);
}
auto operator%=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull {
return &(*lhs = *lhs % rhs);
}
// Compound Bitwise
auto operator&=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull {
return &(*lhs = *lhs & rhs);
}
auto operator|=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull {
return &(*lhs = *lhs | rhs);
}
auto operator^=(MyNumber* _Nonnull lhs, MyNumber rhs) -> MyNumber* _Nonnull {
return &(*lhs = *lhs ^ rhs);
}
// Relational
auto operator==(MyNumber lhs, MyNumber rhs) -> bool {
return lhs.value() == rhs.value();
}
auto operator!=(MyNumber lhs, MyNumber rhs) -> bool {
return lhs.value() != rhs.value();
}
auto operator<(MyNumber lhs, MyNumber rhs) -> bool {
return lhs.value() < rhs.value();
}
auto operator>(MyNumber lhs, MyNumber rhs) -> bool {
return lhs.value() > rhs.value();
}
auto operator<=(MyNumber lhs, MyNumber rhs) -> bool {
return lhs.value() <= rhs.value();
}
auto operator>=(MyNumber lhs, MyNumber rhs) -> bool {
return lhs.value() >= rhs.value();
}
```
```carbon
// main.carbon
library "Main";
import Core library "io";
import Cpp library "my_number.h";
fn PrintBool(b: bool) {
if (b) {
Core.Print(1);
} else {
Core.Print(0);
}
}
fn Run() -> i32 {
// Arithmetic
var num1: Cpp.MyNumber = Cpp.MyNumber.MyNumber(14);
var num2: Cpp.MyNumber = Cpp.MyNumber.MyNumber(5);
Core.Print(num1.value());
Core.Print(num2.value());
Core.Print((num1 + num2).value());
Core.Print((num1 - num2).value());
Core.Print((num1 * num2).value());
Core.Print((num1 / num2).value());
Core.Print((num1 % num2).value());
// Bitwise
var bits1: Cpp.MyNumber = Cpp.MyNumber.MyNumber(12);
var bits2: Cpp.MyNumber = Cpp.MyNumber.MyNumber(10);
Core.Print(bits1.value());
Core.Print(bits2.value());
Core.Print((bits1 & bits2).value());
Core.Print((bits1 | bits2).value());
Core.Print((bits1 ^ bits2).value());
Core.Print((bits1 << 2).value());
Core.Print((bits1 >> 1).value());
// Compound Arithmetic
var c: Cpp.MyNumber = Cpp.MyNumber.MyNumber(100);
Core.Print(c.value());
&c += Cpp.MyNumber.MyNumber(10);
Core.Print(c.value());
&c -= Cpp.MyNumber.MyNumber(20);
Core.Print(c.value());
&c *= Cpp.MyNumber.MyNumber(2);
Core.Print(c.value());
&c /= Cpp.MyNumber.MyNumber(6);
Core.Print(c.value());
&c %= Cpp.MyNumber.MyNumber(9);
Core.Print(c.value());
// Compound Bitwise
&c |= Cpp.MyNumber.MyNumber(12);
Core.Print(c.value());
&c &= Cpp.MyNumber.MyNumber(7);
Core.Print(c.value());
&c ^= Cpp.MyNumber.MyNumber(10);
Core.Print(c.value());
// Relational
var rel1: Cpp.MyNumber = Cpp.MyNumber.MyNumber(20);
var rel2: Cpp.MyNumber = Cpp.MyNumber.MyNumber(30);
var rel3: Cpp.MyNumber = Cpp.MyNumber.MyNumber(20);
Core.Print(rel1.value());
Core.Print(rel2.value());
Core.Print(rel3.value());
PrintBool(rel1 == rel3);
PrintBool(rel1 != rel2);
PrintBool(rel1 < rel2);
PrintBool(rel2 > rel1);
PrintBool(rel1 <= rel3);
PrintBool(rel1 >= rel2);
return 0;
}
```
```shell
$ clang -c my_number.cpp
$ bazel-bin/toolchain/carbon compile main.carbon
$ bazel-bin/toolchain/carbon link my_number.o main.o --output=demo
$ ./demo
14
5
19
9
70
2
4
12
10
8
14
6
48
6
100
110
90
180
30
3
15
7
13
20
30
20
1
1
1
1
1
0
```
Part of https://github.com/carbon-language/carbon-lang/issues/5995.
|
||
 Richard Smith
|
db0a00d713 |
Fix double-destruction of temporaries. (#6010)
Attach the cleanup to the `Temporary` instruction instead of to the `TemporaryStorage` instruction. We create `TemporaryStorage` instructions speculatively when creating an initializing expression, and may overwrite those instructions with other instructions if it turns out that a temporary is not required. Instead, wait until we finalize the temporary and create a `Temporary` instruction to register the cleanup. |
||
|
Boaz Brickner
|
870c5380a0 |
C++ interop: Support importing binary operator+ (#5996)
Triggered by calling a binary operator with LHS being an imported C++
class type.
Not supported (yet):
* Multiple overloads.
* Other operators.
C++ Interop Demo:
```c++
// hello_world.h
class C {
public:
C(int x) : x_(x) {}
auto x() const -> int { return x_; }
private:
int x_ = 0;
};
auto operator+ (C c1, C c2) -> C;
```
```c++
// hello_world.cpp
#include "hello_world.h"
#include <cstdio>
auto operator+ (C c1, C c2) -> C {
printf("Adding %d with %d\n", c1.x(), c2.x());
return C(c1.x() + c2.x());
}
```
```carbon
// main.carbon
library "Main";
import Cpp library "hello_world.h";
fn Run() -> i32 {
let c1 : Cpp.C = Cpp.C.C(7);
let c2 : Cpp.C = Cpp.C.C(8);
let c3 : Cpp.C = c1 + c2;
let c4 : Cpp.C = c3 + c2;
return 0;
}
```
```shell
$ clang -c hello_world.cpp
$ bazel-bin/toolchain/carbon compile main.carbon
$ bazel-bin/toolchain/carbon link hello_world.o main.o --output=demo
$ ./demo
Adding 7 with 8
Adding 15 with 8
```
Part of #5995.
|