carbon-language/carbon-lang
1
0 Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-11-15 15:18:11 +00:00
Code Issues Packages Projects Releases 10 Wiki Activity

Remove global_arena (#814)

Browse Source 
With this, only main.cpp instantiates an arena. Maybe we'll want to split that up more later (e.g., so that the runtime interpreter uses its own arena), but given the intent to have type-checking update the AST, I thought this was a reasonable approach for now in order to avoid ownership complexities.

Fixes #769
This commit is contained in:
Jon Meow authored and GitHub committed 2021-09-09 11:00:57 -07:00
1 parent 3610325c38
commit 90f04700e2
27 files changed
+568 -581
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

executable_semantics/ast/expression_test.cpp
+33 -36
View File
@@ -30,27 +30,32 @@ static auto FakeSourceLoc(int line_num) -> SourceLocation {
return SourceLocation("<test>", line_num);
}
TEST(ExpressionTest, EmptyAsExpression) {
class ExpressionTest : public ::testing::Test {
protected:
Arena arena;
};
TEST_F(ExpressionTest, EmptyAsExpression) {
ParenContents<Expression> contents = {.elements = {},
.has_trailing_comma = false};
Ptr<const Expression> expression =
ExpressionFromParenContents(FakeSourceLoc(1), contents);
ExpressionFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(expression->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(expression->Tag(), Expression::Kind::TupleLiteral);
EXPECT_THAT(cast<TupleLiteral>(*expression).Fields(), IsEmpty());
}
TEST(ExpressionTest, EmptyAsTuple) {
TEST_F(ExpressionTest, EmptyAsTuple) {
ParenContents<Expression> contents = {.elements = {},
.has_trailing_comma = false};
Ptr<const Expression> tuple =
TupleExpressionFromParenContents(FakeSourceLoc(1), contents);
Ptr<const Expression> tuple = TupleExpressionFromParenContents(
PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(tuple->Tag(), Expression::Kind::TupleLiteral);
EXPECT_THAT(cast<TupleLiteral>(*tuple).Fields(), IsEmpty());
}
TEST(ExpressionTest, UnaryNoCommaAsExpression) {
TEST_F(ExpressionTest, UnaryNoCommaAsExpression) {
// Equivalent to a code fragment like
// ```
// (
@@ -59,91 +64,83 @@ TEST(ExpressionTest, UnaryNoCommaAsExpression) {
// ```
ParenContents<Expression> contents = {
.elements = {{.name = std::nullopt,
.term =
global_arena->New<IntLiteral>(FakeSourceLoc(2), 42)}},
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)}},
.has_trailing_comma = false};
Ptr<const Expression> expression =
ExpressionFromParenContents(FakeSourceLoc(1), contents);
ExpressionFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(expression->SourceLoc(), FakeSourceLoc(2));
ASSERT_EQ(expression->Tag(), Expression::Kind::IntLiteral);
}
TEST(ExpressionTest, UnaryNoCommaAsTuple) {
TEST_F(ExpressionTest, UnaryNoCommaAsTuple) {
ParenContents<Expression> contents = {
.elements = {{.name = std::nullopt,
.term =
global_arena->New<IntLiteral>(FakeSourceLoc(2), 42)}},
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)}},
.has_trailing_comma = false};
Ptr<const Expression> tuple =
TupleExpressionFromParenContents(FakeSourceLoc(1), contents);
Ptr<const Expression> tuple = TupleExpressionFromParenContents(
PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(tuple->Tag(), Expression::Kind::TupleLiteral);
EXPECT_THAT(cast<TupleLiteral>(*tuple).Fields(),
ElementsAre(IntFieldNamed("0")));
}
TEST(ExpressionTest, UnaryWithCommaAsExpression) {
TEST_F(ExpressionTest, UnaryWithCommaAsExpression) {
ParenContents<Expression> contents = {
.elements = {{.name = std::nullopt,
.term =
global_arena->New<IntLiteral>(FakeSourceLoc(2), 42)}},
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)}},
.has_trailing_comma = true};
Ptr<const Expression> expression =
ExpressionFromParenContents(FakeSourceLoc(1), contents);
ExpressionFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(expression->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(expression->Tag(), Expression::Kind::TupleLiteral);
EXPECT_THAT(cast<TupleLiteral>(*expression).Fields(),
ElementsAre(IntFieldNamed("0")));
}
TEST(ExpressionTest, UnaryWithCommaAsTuple) {
TEST_F(ExpressionTest, UnaryWithCommaAsTuple) {
ParenContents<Expression> contents = {
.elements = {{.name = std::nullopt,
.term =
global_arena->New<IntLiteral>(FakeSourceLoc(2), 42)}},
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)}},
.has_trailing_comma = true};
Ptr<const Expression> tuple =
TupleExpressionFromParenContents(FakeSourceLoc(1), contents);
Ptr<const Expression> tuple = TupleExpressionFromParenContents(
PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(tuple->Tag(), Expression::Kind::TupleLiteral);
EXPECT_THAT(cast<TupleLiteral>(*tuple).Fields(),
ElementsAre(IntFieldNamed("0")));
}
TEST(ExpressionTest, BinaryAsExpression) {
TEST_F(ExpressionTest, BinaryAsExpression) {
ParenContents<Expression> contents = {
.elements = {{.name = std::nullopt,
.term =
global_arena->New<IntLiteral>(FakeSourceLoc(2), 42)},
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)},
{.name = std::nullopt,
.term =
global_arena->New<IntLiteral>(FakeSourceLoc(3), 42)}},
.term = arena.New<IntLiteral>(FakeSourceLoc(3), 42)}},
.has_trailing_comma = true};
Ptr<const Expression> expression =
ExpressionFromParenContents(FakeSourceLoc(1), contents);
ExpressionFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(expression->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(expression->Tag(), Expression::Kind::TupleLiteral);
EXPECT_THAT(cast<TupleLiteral>(*expression).Fields(),
ElementsAre(IntFieldNamed("0"), IntFieldNamed("1")));
}
TEST(ExpressionTest, BinaryAsTuple) {
TEST_F(ExpressionTest, BinaryAsTuple) {
ParenContents<Expression> contents = {
.elements = {{.name = std::nullopt,
.term =
global_arena->New<IntLiteral>(FakeSourceLoc(2), 42)},
.term = arena.New<IntLiteral>(FakeSourceLoc(2), 42)},
{.name = std::nullopt,
.term =
global_arena->New<IntLiteral>(FakeSourceLoc(3), 42)}},
.term = arena.New<IntLiteral>(FakeSourceLoc(3), 42)}},
.has_trailing_comma = true};
Ptr<const Expression> tuple =
TupleExpressionFromParenContents(FakeSourceLoc(1), contents);
Ptr<const Expression> tuple = TupleExpressionFromParenContents(
PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
ASSERT_EQ(tuple->Tag(), Expression::Kind::TupleLiteral);
EXPECT_THAT(cast<TupleLiteral>(*tuple).Fields(),