Remove global_arena (#814)

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

executable_semantics/ast/pattern.cpp

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