Miscellaneous tuple simplifications (#857)

- Drop unnecessary special-casing of 0-tuples.
- Drop unused constructor.

executable_semantics/ast/pattern.cpp

@@ -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

@@ -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

@@ -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,