carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-10-05 22:02:55 +01: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
2021-09-09 11:00:57 -07:00
committed by GitHub
parent 3610325c38
commit 90f04700e2
27 changed files with 568 additions and 581 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/ast/expression.cpp
+6 -6
View File
@@ -17,21 +17,21 @@ namespace Carbon {
using llvm::cast;
auto ExpressionFromParenContents(
SourceLocation loc, const ParenContents<Expression>& paren_contents)
-> Ptr<const Expression> {
Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents) -> Ptr<const Expression> {
std::optional<Ptr<const Expression>> single_term =
paren_contents.SingleTerm();
if (single_term.has_value()) {
return *single_term;
} else {
return TupleExpressionFromParenContents(loc, paren_contents);
return TupleExpressionFromParenContents(arena, loc, paren_contents);
}
}
auto TupleExpressionFromParenContents(
SourceLocation loc, const ParenContents<Expression>& paren_contents)
-> Ptr<const Expression> {
return global_arena->New<TupleLiteral>(
Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents) -> Ptr<const Expression> {
return arena->New<TupleLiteral>(
loc, paren_contents.TupleElements<FieldInitializer>(loc));
}
executable_semantics/ast/expression.h
+5 -4
View File
@@ -13,6 +13,7 @@
#include "common/ostream.h"
#include "executable_semantics/ast/paren_contents.h"
#include "executable_semantics/ast/source_location.h"
#include "executable_semantics/common/arena.h"
#include "llvm/Support/Compiler.h"
namespace Carbon {
@@ -62,14 +63,14 @@ class Expression {
// grouping if their contents permit that interpretation, or as forming a
// tuple otherwise.
auto ExpressionFromParenContents(
SourceLocation loc, const ParenContents<Expression>& paren_contents)
-> Ptr<const Expression>;
Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents) -> Ptr<const Expression>;
// Converts paren_contents to an Expression, interpreting the parentheses as
// forming a tuple.
auto TupleExpressionFromParenContents(
SourceLocation loc, const ParenContents<Expression>& paren_contents)
-> Ptr<const Expression>;
Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Expression>& paren_contents) -> Ptr<const Expression>;
// A FieldInitializer represents the initialization of a single tuple field.
struct FieldInitializer {
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(),
executable_semantics/ast/pattern.cpp
+11 -9
View File
@@ -54,30 +54,31 @@ void Pattern::Print(llvm::raw_ostream& out) const {
}
}
TuplePattern::TuplePattern(Ptr<const Expression> tuple_literal)
TuplePattern::TuplePattern(Ptr<Arena> arena,
Ptr<const Expression> tuple_literal)
: Pattern(Kind::TuplePattern, tuple_literal->SourceLoc()) {
const auto& tuple = cast<TupleLiteral>(*tuple_literal);
for (const FieldInitializer& init : tuple.Fields()) {
fields.push_back(Field(
init.name, global_arena->New<ExpressionPattern>(init.expression)));
fields.push_back(
Field(init.name, arena->New<ExpressionPattern>(init.expression)));
}
}
auto PatternFromParenContents(SourceLocation loc,
auto PatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Pattern>& paren_contents)
-> Ptr<const Pattern> {
std::optional<Ptr<const Pattern>> single_term = paren_contents.SingleTerm();
if (single_term.has_value()) {
return *single_term;
} else {
return TuplePatternFromParenContents(loc, paren_contents);
return TuplePatternFromParenContents(arena, loc, paren_contents);
}
}
auto TuplePatternFromParenContents(SourceLocation loc,
auto TuplePatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Pattern>& paren_contents)
-> Ptr<const TuplePattern> {
return global_arena->New<TuplePattern>(
return arena->New<TuplePattern>(
loc, paren_contents.TupleElements<TuplePattern::Field>(loc));
}
@@ -101,14 +102,15 @@ AlternativePattern::AlternativePattern(SourceLocation loc,
alternative_name(RequireFieldAccess(alternative).Field()),
arguments(arguments) {}
auto ParenExpressionToParenPattern(const ParenContents<Expression>& contents)
auto ParenExpressionToParenPattern(Ptr<Arena> arena,
const ParenContents<Expression>& contents)
-> ParenContents<Pattern> {
ParenContents<Pattern> result = {
.elements = {}, .has_trailing_comma = contents.has_trailing_comma};
for (const auto& element : contents.elements) {
result.elements.push_back(
{.name = element.name,
.term = global_arena->New<ExpressionPattern>(element.term)});
.term = arena->New<ExpressionPattern>(element.term)});
}
return result;
}
executable_semantics/ast/pattern.h
+5 -4
View File
@@ -111,7 +111,7 @@ class TuplePattern : public Pattern {
// ExpressionPattern.
//
// REQUIRES: tuple_literal->Tag() == Expression::Kind::TupleLiteral
explicit TuplePattern(Ptr<const Expression> tuple_literal);
TuplePattern(Ptr<Arena> arena, Ptr<const Expression> tuple_literal);
static auto classof(const Pattern* pattern) -> bool {
return pattern->Tag() == Kind::TuplePattern;
@@ -126,19 +126,20 @@ class TuplePattern : public Pattern {
// Converts paren_contents to a Pattern, interpreting the parentheses as
// grouping if their contents permit that interpretation, or as forming a
// tuple otherwise.
auto PatternFromParenContents(SourceLocation loc,
auto PatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Pattern>& paren_contents)
-> Ptr<const Pattern>;
// Converts paren_contents to a TuplePattern, interpreting the parentheses as
// forming a tuple.
auto TuplePatternFromParenContents(SourceLocation loc,
auto TuplePatternFromParenContents(Ptr<Arena> arena, SourceLocation loc,
const ParenContents<Pattern>& paren_contents)
-> Ptr<const TuplePattern>;
// Converts `contents` to ParenContents<Pattern> by replacing each Expression
// with an ExpressionPattern.
auto ParenExpressionToParenPattern(const ParenContents<Expression>& contents)
auto ParenExpressionToParenPattern(Ptr<Arena> arena,
const ParenContents<Expression>& contents)
-> ParenContents<Pattern>;
// A pattern that matches an alternative of a choice type.
executable_semantics/ast/pattern_test.cpp
+29 -24
View File
@@ -29,26 +29,31 @@ static auto FakeSourceLoc(int line_num) -> SourceLocation {
return SourceLocation("<test>", line_num);
}
TEST(PatternTest, EmptyAsPattern) {
class PatternTest : public ::testing::Test {
protected:
Arena arena;
};
TEST_F(PatternTest, EmptyAsPattern) {
ParenContents<Pattern> contents = {.elements = {},
.has_trailing_comma = false};
Ptr<const Pattern> pattern =
PatternFromParenContents(FakeSourceLoc(1), contents);
PatternFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(pattern->SourceLoc(), FakeSourceLoc(1));
ASSERT_TRUE(isa<TuplePattern>(*pattern));
EXPECT_THAT(cast<TuplePattern>(*pattern).Fields(), IsEmpty());
}
TEST(PatternTest, EmptyAsTuplePattern) {
TEST_F(PatternTest, EmptyAsTuplePattern) {
ParenContents<Pattern> contents = {.elements = {},
.has_trailing_comma = false};
Ptr<const TuplePattern> tuple =
TuplePatternFromParenContents(FakeSourceLoc(1), contents);
TuplePatternFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
EXPECT_THAT(tuple->Fields(), IsEmpty());
}
TEST(PatternTest, UnaryNoCommaAsPattern) {
TEST_F(PatternTest, UnaryNoCommaAsPattern) {
// Equivalent to a code fragment like
// ```
// (
@@ -57,79 +62,79 @@ TEST(PatternTest, UnaryNoCommaAsPattern) {
// ```
ParenContents<Pattern> contents = {
.elements = {{.name = std::nullopt,
.term = global_arena->New<AutoPattern>(FakeSourceLoc(2))}},
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = false};
Ptr<const Pattern> pattern =
PatternFromParenContents(FakeSourceLoc(1), contents);
PatternFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(pattern->SourceLoc(), FakeSourceLoc(2));
ASSERT_TRUE(isa<AutoPattern>(*pattern));
}
TEST(PatternTest, UnaryNoCommaAsTuplePattern) {
TEST_F(PatternTest, UnaryNoCommaAsTuplePattern) {
ParenContents<Pattern> contents = {
.elements = {{.name = std::nullopt,
.term = global_arena->New<AutoPattern>(FakeSourceLoc(2))}},
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = false};
Ptr<const TuplePattern> tuple =
TuplePatternFromParenContents(FakeSourceLoc(1), contents);
TuplePatternFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
EXPECT_THAT(tuple->Fields(), ElementsAre(AutoFieldNamed("0")));
}
TEST(PatternTest, UnaryWithCommaAsPattern) {
TEST_F(PatternTest, UnaryWithCommaAsPattern) {
ParenContents<Pattern> contents = {
.elements = {{.name = std::nullopt,
.term = global_arena->New<AutoPattern>(FakeSourceLoc(2))}},
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = true};
Ptr<const Pattern> pattern =
PatternFromParenContents(FakeSourceLoc(1), contents);
PatternFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(pattern->SourceLoc(), FakeSourceLoc(1));
ASSERT_TRUE(isa<TuplePattern>(*pattern));
EXPECT_THAT(cast<TuplePattern>(*pattern).Fields(),
ElementsAre(AutoFieldNamed("0")));
}
TEST(PatternTest, UnaryWithCommaAsTuplePattern) {
TEST_F(PatternTest, UnaryWithCommaAsTuplePattern) {
ParenContents<Pattern> contents = {
.elements = {{.name = std::nullopt,
.term = global_arena->New<AutoPattern>(FakeSourceLoc(2))}},
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = true};
Ptr<const TuplePattern> tuple =
TuplePatternFromParenContents(FakeSourceLoc(1), contents);
TuplePatternFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
EXPECT_THAT(tuple->Fields(), ElementsAre(AutoFieldNamed("0")));
}
TEST(PatternTest, BinaryAsPattern) {
TEST_F(PatternTest, BinaryAsPattern) {
ParenContents<Pattern> contents = {
.elements = {{.name = std::nullopt,
.term = global_arena->New<AutoPattern>(FakeSourceLoc(2))},
.term = arena.New<AutoPattern>(FakeSourceLoc(2))},
{.name = std::nullopt,
.term = global_arena->New<AutoPattern>(FakeSourceLoc(2))}},
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = true};
Ptr<const Pattern> pattern =
PatternFromParenContents(FakeSourceLoc(1), contents);
PatternFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(pattern->SourceLoc(), FakeSourceLoc(1));
ASSERT_TRUE(isa<TuplePattern>(*pattern));
EXPECT_THAT(cast<TuplePattern>(*pattern).Fields(),
ElementsAre(AutoFieldNamed("0"), AutoFieldNamed("1")));
}
TEST(PatternTest, BinaryAsTuplePattern) {
TEST_F(PatternTest, BinaryAsTuplePattern) {
ParenContents<Pattern> contents = {
.elements = {{.name = std::nullopt,
.term = global_arena->New<AutoPattern>(FakeSourceLoc(2))},
.term = arena.New<AutoPattern>(FakeSourceLoc(2))},
{.name = std::nullopt,
.term = global_arena->New<AutoPattern>(FakeSourceLoc(2))}},
.term = arena.New<AutoPattern>(FakeSourceLoc(2))}},
.has_trailing_comma = true};
Ptr<const TuplePattern> tuple =
TuplePatternFromParenContents(FakeSourceLoc(1), contents);
TuplePatternFromParenContents(PtrTo(arena), FakeSourceLoc(1), contents);
EXPECT_EQ(tuple->SourceLoc(), FakeSourceLoc(1));
EXPECT_THAT(tuple->Fields(),
ElementsAre(AutoFieldNamed("0"), AutoFieldNamed("1")));
executable_semantics/ast/statement.h
+2 -2
View File
@@ -135,8 +135,8 @@ class If : public Statement {
class Return : public Statement {
public:
explicit Return(SourceLocation loc)
: Return(loc, global_arena->New<TupleLiteral>(loc), true) {}
Return(Ptr<Arena> arena, SourceLocation loc)
: Return(loc, arena->New<TupleLiteral>(loc), true) {}
Return(SourceLocation loc, Ptr<const Expression> exp, bool is_omitted_exp)
: Statement(Kind::Return, loc),
exp(exp),