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

Miscellaneous tuple simplifications (#857)

Browse Source 
- Drop unnecessary special-casing of 0-tuples.
- Drop unused constructor.
This commit is contained in:
Geoff Romer
2021-09-27 12:10:16 -07:00
committed by GitHub
parent 5aa958345b
commit 532948d9a5
3 changed files with 5 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/ast/pattern.cpp
-10
View File
@@ -54,16 +54,6 @@ void Pattern::Print(llvm::raw_ostream& out) const {
}
}
TuplePattern::TuplePattern(Nonnull<Arena*> arena,
Nonnull<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, arena->New<ExpressionPattern>(init.expression)));
}
}
auto PatternFromParenContents(Nonnull<Arena*> arena, SourceLocation loc,
const ParenContents<Pattern>& paren_contents)
-> Nonnull<Pattern*> {
executable_semantics/ast/pattern.h
-6
View File
@@ -109,12 +109,6 @@ class TuplePattern : public Pattern {
TuplePattern(SourceLocation loc, std::vector<Field> fields)
: Pattern(Kind::TuplePattern, loc), fields(std::move(fields)) {}
// Converts tuple_literal to a TuplePattern, by wrapping each field in an
// ExpressionPattern.
//
// REQUIRES: tuple_literal->Tag() == Expression::Kind::TupleLiteral
TuplePattern(Nonnull<Arena*> arena, Nonnull<Expression*> tuple_literal);
static auto classof(const Pattern* pattern) -> bool {
return pattern->Tag() == Kind::TuplePattern;
}
executable_semantics/interpreter/interpreter.cpp
+5 -28
View File
@@ -413,14 +413,8 @@ auto Interpreter::StepLvalue() -> Transition {
}
}
case Expression::Kind::TupleLiteral: {
if (act->Pos() == 0) {
// { {(f1=e1,...) :: C, E, F} :: S, H}
// -> { {e1 :: (f1=[],...) :: C, E, F} :: S, H}
Nonnull<const Expression*> e1 =
cast<TupleLiteral>(*exp).Fields()[0].expression;
return Spawn{arena->New<LValAction>(e1)};
} else if (act->Pos() !=
static_cast<int>(cast<TupleLiteral>(*exp).Fields().size())) {
if (act->Pos() <
static_cast<int>(cast<TupleLiteral>(*exp).Fields().size())) {
// { { vk :: (f1=v1,..., fk=[],fk+1=ek+1,...) :: C, E, F} :: S,
// H}
// -> { { ek+1 :: (f1=v1,..., fk=vk, fk+1=[],...) :: C, E, F} :: S,
@@ -485,18 +479,8 @@ auto Interpreter::StepExp() -> Transition {
}
}
case Expression::Kind::TupleLiteral: {
if (act->Pos() == 0) {
if (cast<TupleLiteral>(*exp).Fields().size() > 0) {
// { {(f1=e1,...) :: C, E, F} :: S, H}
// -> { {e1 :: (f1=[],...) :: C, E, F} :: S, H}
Nonnull<const Expression*> e1 =
cast<TupleLiteral>(*exp).Fields()[0].expression;
return Spawn{arena->New<ExpressionAction>(e1)};
} else {
return Done{CreateTuple(act, exp)};
}
} else if (act->Pos() !=
static_cast<int>(cast<TupleLiteral>(*exp).Fields().size())) {
if (act->Pos() <
static_cast<int>(cast<TupleLiteral>(*exp).Fields().size())) {
// { { vk :: (f1=v1,..., fk=[],fk+1=ek+1,...) :: C, E, F} :: S,
// H}
// -> { { ek+1 :: (f1=v1,..., fk=vk, fk+1=[],...) :: C, E, F} :: S,
@@ -672,14 +656,7 @@ auto Interpreter::StepPattern() -> Transition {
}
case Pattern::Kind::TuplePattern: {
const auto& tuple = cast<TuplePattern>(*pattern);
if (act->Pos() == 0) {
if (tuple.Fields().empty()) {
return Done{TupleValue::Empty()};
} else {
Nonnull<const Pattern*> p1 = tuple.Fields()[0].pattern;
return Spawn{(arena->New<PatternAction>(p1))};
}
} else if (act->Pos() != static_cast<int>(tuple.Fields().size())) {
if (act->Pos() < static_cast<int>(tuple.Fields().size())) {
// { { vk :: (f1=v1,..., fk=[],fk+1=ek+1,...) :: C, E, F} :: S,
// H}
// -> { { ek+1 :: (f1=v1,..., fk=vk, fk+1=[],...) :: C, E, F} :: S,