Private unions (#492)

* changed union of Statement to be private

* changed the union in Expression to be private

* changed union in Value to be private

* changed AST constructors to be static methods

* updates to syntax unit tests

executable_semantics/ast/expression.cpp

@@ -4,32 +4,83 @@
 
 #include "executable_semantics/ast/expression.h"
 
+#include <cassert>
 #include <iostream>
 
 namespace Carbon {
 
-auto MakeTypeType(int line_num) -> const Expression* {
+Variable Expression::GetVariable() const {
+  assert(tag == ExpressionKind::Variable);
+  return u.variable;
+}
+
+FieldAccess Expression::GetFieldAccess() const {
+  assert(tag == ExpressionKind::GetField);
+  return u.get_field;
+}
+
+Index Expression::GetIndex() const {
+  assert(tag == ExpressionKind::Index);
+  return u.index;
+}
+
+PatternVariable Expression::GetPatternVariable() const {
+  assert(tag == ExpressionKind::PatternVariable);
+  return u.pattern_variable;
+}
+
+int Expression::GetInteger() const {
+  assert(tag == ExpressionKind::Integer);
+  return u.integer;
+}
+
+bool Expression::GetBoolean() const {
+  assert(tag == ExpressionKind::Boolean);
+  return u.boolean;
+}
+
+Tuple Expression::GetTuple() const {
+  assert(tag == ExpressionKind::Tuple);
+  return u.tuple;
+}
+
+PrimitiveOperator Expression::GetPrimitiveOperator() const {
+  assert(tag == ExpressionKind::PrimitiveOp);
+  return u.primitive_op;
+}
+
+Call Expression::GetCall() const {
+  assert(tag == ExpressionKind::Call);
+  return u.call;
+}
+
+FunctionType Expression::GetFunctionType() const {
+  assert(tag == ExpressionKind::FunctionT);
+  return u.function_type;
+}
+
+auto Expression::MakeTypeType(int line_num) -> const Expression* {
   auto* t = new Expression();
   t->tag = ExpressionKind::TypeT;
   t->line_num = line_num;
   return t;
 }
 
-auto MakeIntType(int line_num) -> const Expression* {
+auto Expression::MakeIntType(int line_num) -> const Expression* {
   auto* t = new Expression();
   t->tag = ExpressionKind::IntT;
   t->line_num = line_num;
   return t;
 }
 
-auto MakeBoolType(int line_num) -> const Expression* {
+auto Expression::MakeBoolType(int line_num) -> const Expression* {
   auto* t = new Expression();
   t->tag = ExpressionKind::BoolT;
   t->line_num = line_num;
   return t;
 }
 
-auto MakeAutoType(int line_num) -> const Expression* {
+auto Expression::MakeAutoType(int line_num) -> const Expression* {
   auto* t = new Expression();
   t->tag = ExpressionKind::AutoT;
   t->line_num = line_num;
@@ -37,15 +88,15 @@ auto MakeAutoType(int line_num) -> const Expression* {
 }
 
 // Returns a Continuation type AST node at the given source location.
-auto MakeContinuationType(int line_num) -> const Expression* {
+auto Expression::MakeContinuationType(int line_num) -> const Expression* {
   auto* type = new Expression();
   type->tag = ExpressionKind::ContinuationT;
   type->line_num = line_num;
   return type;
 }
 
-auto MakeFunType(int line_num, const Expression* param, const Expression* ret)
-    -> const Expression* {
+auto Expression::MakeFunType(int line_num, const Expression* param,
+                             const Expression* ret) -> const Expression* {
   auto* t = new Expression();
   t->tag = ExpressionKind::FunctionT;
   t->line_num = line_num;
@@ -54,7 +105,7 @@ auto MakeFunType(int line_num, const Expression* param, const Expression* ret)
   return t;
 }
 
-auto MakeVar(int line_num, std::string var) -> const Expression* {
+auto Expression::MakeVar(int line_num, std::string var) -> const Expression* {
   auto* v = new Expression();
   v->line_num = line_num;
   v->tag = ExpressionKind::Variable;
@@ -62,8 +113,8 @@ auto MakeVar(int line_num, std::string var) -> const Expression* {
   return v;
 }
 
-auto MakeVarPat(int line_num, std::string var, const Expression* type)
-    -> const Expression* {
+auto Expression::MakeVarPat(int line_num, std::string var,
+                            const Expression* type) -> const Expression* {
   auto* v = new Expression();
   v->line_num = line_num;
   v->tag = ExpressionKind::PatternVariable;
@@ -72,7 +123,7 @@ auto MakeVarPat(int line_num, std::string var, const Expression* type)
   return v;
 }
 
-auto MakeInt(int line_num, int i) -> const Expression* {
+auto Expression::MakeInt(int line_num, int i) -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
   e->tag = ExpressionKind::Integer;
@@ -80,7 +131,7 @@ auto MakeInt(int line_num, int i) -> const Expression* {
   return e;
 }
 
-auto MakeBool(int line_num, bool b) -> const Expression* {
+auto Expression::MakeBool(int line_num, bool b) -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
   e->tag = ExpressionKind::Boolean;
@@ -88,8 +139,9 @@ auto MakeBool(int line_num, bool b) -> const Expression* {
   return e;
 }
 
-auto MakeOp(int line_num, enum Operator op,
-            std::vector<const Expression*>* args) -> const Expression* {
+auto Expression::MakeOp(int line_num, enum Operator op,
+                        std::vector<const Expression*>* args)
+    -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
   e->tag = ExpressionKind::PrimitiveOp;
@@ -98,7 +150,7 @@ auto MakeOp(int line_num, enum Operator op,
   return e;
 }
 
-auto MakeUnOp(int line_num, enum Operator op, const Expression* arg)
+auto Expression::MakeUnOp(int line_num, enum Operator op, const Expression* arg)
     -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
@@ -110,8 +162,9 @@ auto MakeUnOp(int line_num, enum Operator op, const Expression* arg)
   return e;
 }
 
-auto MakeBinOp(int line_num, enum Operator op, const Expression* arg1,
-               const Expression* arg2) -> const Expression* {
+auto Expression::MakeBinOp(int line_num, enum Operator op,
+                           const Expression* arg1, const Expression* arg2)
+    -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
   e->tag = ExpressionKind::PrimitiveOp;
@@ -123,8 +176,8 @@ auto MakeBinOp(int line_num, enum Operator op, const Expression* arg1,
   return e;
 }
 
-auto MakeCall(int line_num, const Expression* fun, const Expression* arg)
-    -> const Expression* {
+auto Expression::MakeCall(int line_num, const Expression* fun,
+                          const Expression* arg) -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
   e->tag = ExpressionKind::Call;
@@ -133,8 +186,8 @@ auto MakeCall(int line_num, const Expression* fun, const Expression* arg)
   return e;
 }
 
-auto MakeGetField(int line_num, const Expression* exp, std::string field)
-    -> const Expression* {
+auto Expression::MakeGetField(int line_num, const Expression* exp,
+                              std::string field) -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
   e->tag = ExpressionKind::GetField;
@@ -143,7 +196,7 @@ auto MakeGetField(int line_num, const Expression* exp, std::string field)
   return e;
 }
 
-auto MakeTuple(int line_num, std::vector<FieldInitializer>* args)
+auto Expression::MakeTuple(int line_num, std::vector<FieldInitializer>* args)
     -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
@@ -171,7 +224,7 @@ auto MakeTuple(int line_num, std::vector<FieldInitializer>* args)
 // Create an AST node for an empty tuple.
 // TODO(geoffromer): remove this and rewrite its callers to use
 // `MakeTuple(line_num, {})`, once that works.
-auto MakeUnit(int line_num) -> const Expression* {
+auto Expression::MakeUnit(int line_num) -> const Expression* {
   auto* unit = new Expression();
   unit->line_num = line_num;
   unit->tag = ExpressionKind::Tuple;
@@ -180,8 +233,8 @@ auto MakeUnit(int line_num) -> const Expression* {
   return unit;
 }
 
-auto MakeIndex(int line_num, const Expression* exp, const Expression* i)
-    -> const Expression* {
+auto Expression::MakeIndex(int line_num, const Expression* exp,
+                           const Expression* i) -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
   e->tag = ExpressionKind::Index;
@@ -230,63 +283,65 @@ static void PrintFields(std::vector<FieldInitializer>* fields) {
 void PrintExp(const Expression* e) {
   switch (e->tag) {
     case ExpressionKind::Index:
-      PrintExp(e->u.index.aggregate);
+      PrintExp(e->GetIndex().aggregate);
       std::cout << "[";
-      PrintExp(e->u.index.offset);
+      PrintExp(e->GetIndex().offset);
       std::cout << "]";
       break;
     case ExpressionKind::GetField:
-      PrintExp(e->u.get_field.aggregate);
+      PrintExp(e->GetFieldAccess().aggregate);
       std::cout << ".";
-      std::cout << *e->u.get_field.field;
+      std::cout << *e->GetFieldAccess().field;
       break;
     case ExpressionKind::Tuple:
       std::cout << "(";
-      PrintFields(e->u.tuple.fields);
+      PrintFields(e->GetTuple().fields);
       std::cout << ")";
       break;
     case ExpressionKind::Integer:
-      std::cout << e->u.integer;
+      std::cout << e->GetInteger();
       break;
     case ExpressionKind::Boolean:
       std::cout << std::boolalpha;
-      std::cout << e->u.boolean;
+      std::cout << e->GetBoolean();
       break;
-    case ExpressionKind::PrimitiveOp:
+    case ExpressionKind::PrimitiveOp: {
       std::cout << "(";
-      if (e->u.primitive_op.arguments->size() == 0) {
-        PrintOp(e->u.primitive_op.op);
-      } else if (e->u.primitive_op.arguments->size() == 1) {
-        PrintOp(e->u.primitive_op.op);
+      PrimitiveOperator op = e->GetPrimitiveOperator();
+      if (op.arguments->size() == 0) {
+        PrintOp(op.op);
+      } else if (op.arguments->size() == 1) {
+        PrintOp(op.op);
         std::cout << " ";
-        auto iter = e->u.primitive_op.arguments->begin();
+        auto iter = op.arguments->begin();
         PrintExp(*iter);
-      } else if (e->u.primitive_op.arguments->size() == 2) {
-        auto iter = e->u.primitive_op.arguments->begin();
+      } else if (op.arguments->size() == 2) {
+        auto iter = op.arguments->begin();
         PrintExp(*iter);
         std::cout << " ";
-        PrintOp(e->u.primitive_op.op);
+        PrintOp(op.op);
         std::cout << " ";
         ++iter;
         PrintExp(*iter);
       }
       std::cout << ")";
       break;
+    }
     case ExpressionKind::Variable:
-      std::cout << *e->u.variable.name;
+      std::cout << *e->GetVariable().name;
       break;
     case ExpressionKind::PatternVariable:
-      PrintExp(e->u.pattern_variable.type);
+      PrintExp(e->GetPatternVariable().type);
       std::cout << ": ";
-      std::cout << *e->u.pattern_variable.name;
+      std::cout << *e->GetPatternVariable().name;
       break;
     case ExpressionKind::Call:
-      PrintExp(e->u.call.function);
-      if (e->u.call.argument->tag == ExpressionKind::Tuple) {
-        PrintExp(e->u.call.argument);
+      PrintExp(e->GetCall().function);
+      if (e->GetCall().argument->tag == ExpressionKind::Tuple) {
+        PrintExp(e->GetCall().argument);
       } else {
         std::cout << "(";
-        PrintExp(e->u.call.argument);
+        PrintExp(e->GetCall().argument);
         std::cout << ")";
       }
       break;
@@ -307,9 +362,9 @@ void PrintExp(const Expression* e) {
       break;
     case ExpressionKind::FunctionT:
       std::cout << "fn ";
-      PrintExp(e->u.function_type.parameter);
+      PrintExp(e->GetFunctionType().parameter);
       std::cout << " -> ";
-      PrintExp(e->u.function_type.return_type);
+      PrintExp(e->GetFunctionType().return_type);
       break;
   }
 }

executable_semantics/ast/expression.h

@@ -49,86 +49,104 @@ enum class Operator {
   Sub,
 };
 
+struct Expression;
+
+struct Variable {
+  std::string* name;
+};
+
+struct FieldAccess {
+  const Expression* aggregate;
+  std::string* field;
+};
+
+struct Index {
+  const Expression* aggregate;
+  const Expression* offset;
+};
+
+struct PatternVariable {
+  std::string* name;
+  const Expression* type;
+};
+
+struct Tuple {
+  std::vector<FieldInitializer>* fields;
+};
+
+struct PrimitiveOperator {
+  Operator op;
+  std::vector<const Expression*>* arguments;
+};
+
+struct Call {
+  const Expression* function;
+  const Expression* argument;
+};
+
+struct FunctionType {
+  const Expression* parameter;
+  const Expression* return_type;
+};
+
 struct Expression {
   int line_num;
   ExpressionKind tag;
+
+  static auto MakeVar(int line_num, std::string var) -> const Expression*;
+  static auto MakeVarPat(int line_num, std::string var, const Expression* type)
+      -> const Expression*;
+  static auto MakeInt(int line_num, int i) -> const Expression*;
+  static auto MakeBool(int line_num, bool b) -> const Expression*;
+  static auto MakeOp(int line_num, Operator op,
+                     std::vector<const Expression*>* args) -> const Expression*;
+  static auto MakeUnOp(int line_num, enum Operator op, const Expression* arg)
+      -> const Expression*;
+  static auto MakeBinOp(int line_num, enum Operator op, const Expression* arg1,
+                        const Expression* arg2) -> const Expression*;
+  static auto MakeCall(int line_num, const Expression* fun,
+                       const Expression* arg) -> const Expression*;
+  static auto MakeGetField(int line_num, const Expression* exp,
+                           std::string field) -> const Expression*;
+  static auto MakeTuple(int line_num, std::vector<FieldInitializer>* args)
+      -> const Expression*;
+  static auto MakeUnit(int line_num) -> const Expression*;
+  static auto MakeIndex(int line_num, const Expression* exp,
+                        const Expression* i) -> const Expression*;
+  static auto MakeTypeType(int line_num) -> const Expression*;
+  static auto MakeIntType(int line_num) -> const Expression*;
+  static auto MakeBoolType(int line_num) -> const Expression*;
+  static auto MakeFunType(int line_num, const Expression* param,
+                          const Expression* ret) -> const Expression*;
+  static auto MakeAutoType(int line_num) -> const Expression*;
+  static auto MakeContinuationType(int line_num) -> const Expression*;
+
+  Variable GetVariable() const;
+  FieldAccess GetFieldAccess() const;
+  Index GetIndex() const;
+  PatternVariable GetPatternVariable() const;
+  int GetInteger() const;
+  bool GetBoolean() const;
+  Tuple GetTuple() const;
+  PrimitiveOperator GetPrimitiveOperator() const;
+  Call GetCall() const;
+  FunctionType GetFunctionType() const;
+
+ private:
   union {
-    struct {
-      std::string* name;
-    } variable;
-
-    struct {
-      const Expression* aggregate;
-      std::string* field;
-    } get_field;
-
-    struct {
-      const Expression* aggregate;
-      const Expression* offset;
-    } index;
-
-    struct {
-      std::string* name;
-      const Expression* type;
-    } pattern_variable;
-
+    Variable variable;
+    FieldAccess get_field;
+    Index index;
+    PatternVariable pattern_variable;
     int integer;
     bool boolean;
-
-    struct {
-      std::vector<FieldInitializer>* fields;
-    } tuple;
-
-    struct {
-      Operator op;
-      std::vector<const Expression*>* arguments;
-    } primitive_op;
-
-    struct {
-      const Expression* function;
-      const Expression* argument;
-    } call;
-
-    struct {
-      const Expression* parameter;
-      const Expression* return_type;
-    } function_type;
-
+    Tuple tuple;
+    PrimitiveOperator primitive_op;
+    Call call;
+    FunctionType function_type;
   } u;
 };
 
-auto MakeVar(int line_num, std::string var) -> const Expression*;
-auto MakeVarPat(int line_num, std::string var, const Expression* type)
-    -> const Expression*;
-auto MakeInt(int line_num, int i) -> const Expression*;
-auto MakeBool(int line_num, bool b) -> const Expression*;
-auto MakeOp(int line_num, Operator op, std::vector<const Expression*>* args)
-    -> const Expression*;
-auto MakeUnOp(int line_num, enum Operator op, const Expression* arg)
-    -> const Expression*;
-auto MakeBinOp(int line_num, enum Operator op, const Expression* arg1,
-               const Expression* arg2) -> const Expression*;
-auto MakeCall(int line_num, const Expression* fun, const Expression* arg)
-    -> const Expression*;
-auto MakeGetField(int line_num, const Expression* exp, std::string field)
-    -> const Expression*;
-auto MakeTuple(int line_num, std::vector<FieldInitializer>* args)
-    -> const Expression*;
-// Create an AST node for an empty tuple.
-auto MakeUnit(int line_num) -> const Expression*;
-auto MakeIndex(int line_num, const Expression* exp, const Expression* i)
-    -> const Expression*;
-
-auto MakeTypeType(int line_num) -> const Expression*;
-auto MakeIntType(int line_num) -> const Expression*;
-auto MakeBoolType(int line_num) -> const Expression*;
-auto MakeFunType(int line_num, const Expression* param, const Expression* ret)
-    -> const Expression*;
-auto MakeAutoType(int line_num) -> const Expression*;
-// Returns a Continuation type AST node at the given source location,
-// which is the type of a continuation value.
-auto MakeContinuationType(int line_num) -> const Expression*;
-
 void PrintExp(const Expression* exp);
 
 }  // namespace Carbon

executable_semantics/ast/statement.cpp

@@ -4,11 +4,68 @@
 
 #include "executable_semantics/ast/statement.h"
 
+#include <cassert>
 #include <iostream>
 
 namespace Carbon {
 
-auto MakeExpStmt(int line_num, const Expression* exp) -> const Statement* {
+const Expression* Statement::GetExpression() const {
+  assert(tag == StatementKind::ExpressionStatement);
+  return u.exp;
+}
+
+Assignment Statement::GetAssign() const {
+  assert(tag == StatementKind::Assign);
+  return u.assign;
+}
+
+VariableDefinition Statement::GetVariableDefinition() const {
+  assert(tag == StatementKind::VariableDefinition);
+  return u.variable_definition;
+}
+
+IfStatement Statement::GetIf() const {
+  assert(tag == StatementKind::If);
+  return u.if_stmt;
+}
+
+const Expression* Statement::GetReturn() const {
+  assert(tag == StatementKind::Return);
+  return u.return_stmt;
+}
+
+Sequence Statement::GetSequence() const {
+  assert(tag == StatementKind::Sequence);
+  return u.sequence;
+}
+
+Block Statement::GetBlock() const {
+  assert(tag == StatementKind::Block);
+  return u.block;
+}
+
+While Statement::GetWhile() const {
+  assert(tag == StatementKind::While);
+  return u.while_stmt;
+}
+
+Match Statement::GetMatch() const {
+  assert(tag == StatementKind::Match);
+  return u.match_stmt;
+}
+
+Continuation Statement::GetContinuation() const {
+  assert(tag == StatementKind::Continuation);
+  return u.continuation;
+}
+
+Run Statement::GetRun() const {
+  assert(tag == StatementKind::Run);
+  return u.run;
+}
+
+auto Statement::MakeExpStmt(int line_num, const Expression* exp)
+    -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::ExpressionStatement;
@@ -16,8 +73,8 @@ auto MakeExpStmt(int line_num, const Expression* exp) -> const Statement* {
   return s;
 }
 
-auto MakeAssign(int line_num, const Expression* lhs, const Expression* rhs)
-    -> const Statement* {
+auto Statement::MakeAssign(int line_num, const Expression* lhs,
+                           const Expression* rhs) -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::Assign;
@@ -26,8 +83,8 @@ auto MakeAssign(int line_num, const Expression* lhs, const Expression* rhs)
   return s;
 }
 
-auto MakeVarDef(int line_num, const Expression* pat, const Expression* init)
-    -> const Statement* {
+auto Statement::MakeVarDef(int line_num, const Expression* pat,
+                           const Expression* init) -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::VariableDefinition;
@@ -36,8 +93,9 @@ auto MakeVarDef(int line_num, const Expression* pat, const Expression* init)
   return s;
 }
 
-auto MakeIf(int line_num, const Expression* cond, const Statement* then_stmt,
-            const Statement* else_stmt) -> const Statement* {
+auto Statement::MakeIf(int line_num, const Expression* cond,
+                       const Statement* then_stmt, const Statement* else_stmt)
+    -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::If;
@@ -47,8 +105,8 @@ auto MakeIf(int line_num, const Expression* cond, const Statement* then_stmt,
   return s;
 }
 
-auto MakeWhile(int line_num, const Expression* cond, const Statement* body)
-    -> const Statement* {
+auto Statement::MakeWhile(int line_num, const Expression* cond,
+                          const Statement* body) -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::While;
@@ -57,21 +115,22 @@ auto MakeWhile(int line_num, const Expression* cond, const Statement* body)
   return s;
 }
 
-auto MakeBreak(int line_num) -> const Statement* {
+auto Statement::MakeBreak(int line_num) -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::Break;
   return s;
 }
 
-auto MakeContinue(int line_num) -> const Statement* {
+auto Statement::MakeContinue(int line_num) -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::Continue;
   return s;
 }
 
-auto MakeReturn(int line_num, const Expression* e) -> const Statement* {
+auto Statement::MakeReturn(int line_num, const Expression* e)
+    -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::Return;
@@ -79,7 +138,7 @@ auto MakeReturn(int line_num, const Expression* e) -> const Statement* {
   return s;
 }
 
-auto MakeSeq(int line_num, const Statement* s1, const Statement* s2)
+auto Statement::MakeSeq(int line_num, const Statement* s1, const Statement* s2)
     -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
@@ -89,7 +148,8 @@ auto MakeSeq(int line_num, const Statement* s1, const Statement* s2)
   return s;
 }
 
-auto MakeBlock(int line_num, const Statement* stmt) -> const Statement* {
+auto Statement::MakeBlock(int line_num, const Statement* stmt)
+    -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::Block;
@@ -97,7 +157,7 @@ auto MakeBlock(int line_num, const Statement* stmt) -> const Statement* {
   return s;
 }
 
-auto MakeMatch(
+auto Statement::MakeMatch(
     int line_num, const Expression* exp,
     std::list<std::pair<const Expression*, const Statement*>>* clauses)
     -> const Statement* {
@@ -111,8 +171,9 @@ auto MakeMatch(
 
 // Returns an AST node for a continuation statement give its line number and
 // parts.
-auto MakeContinuationStatement(int line_num, std::string continuation_variable,
-                               const Statement* body) -> const Statement* {
+auto Statement::MakeContinuation(int line_num,
+                                 std::string continuation_variable,
+                                 const Statement* body) -> const Statement* {
   auto* continuation = new Statement();
   continuation->line_num = line_num;
   continuation->tag = StatementKind::Continuation;
@@ -123,7 +184,8 @@ auto MakeContinuationStatement(int line_num, std::string continuation_variable,
 }
 
 // Returns an AST node for a run statement give its line number and argument.
-auto MakeRun(int line_num, const Expression* argument) -> const Statement* {
+auto Statement::MakeRun(int line_num, const Expression* argument)
+    -> const Statement* {
   auto* run = new Statement();
   run->line_num = line_num;
   run->tag = StatementKind::Run;
@@ -132,7 +194,7 @@ auto MakeRun(int line_num, const Expression* argument) -> const Statement* {
 }
 
 // Returns an AST node for an await statement give its line number.
-auto MakeAwait(int line_num) -> const Statement* {
+auto Statement::MakeAwait(int line_num) -> const Statement* {
   auto* await = new Statement();
   await->line_num = line_num;
   await->tag = StatementKind::Await;
@@ -150,11 +212,11 @@ void PrintStatement(const Statement* s, int depth) {
   switch (s->tag) {
     case StatementKind::Match:
       std::cout << "match (";
-      PrintExp(s->u.match_stmt.exp);
+      PrintExp(s->GetMatch().exp);
       std::cout << ") {";
       if (depth < 0 || depth > 1) {
         std::cout << std::endl;
-        for (auto& clause : *s->u.match_stmt.clauses) {
+        for (auto& clause : *s->GetMatch().clauses) {
           std::cout << "case ";
           PrintExp(clause.first);
           std::cout << " =>" << std::endl;
@@ -168,9 +230,9 @@ void PrintStatement(const Statement* s, int depth) {
       break;
     case StatementKind::While:
       std::cout << "while (";
-      PrintExp(s->u.while_stmt.cond);
+      PrintExp(s->GetWhile().cond);
       std::cout << ")" << std::endl;
-      PrintStatement(s->u.while_stmt.body, depth - 1);
+      PrintStatement(s->GetWhile().body, depth - 1);
       break;
     case StatementKind::Break:
       std::cout << "break;";
@@ -180,49 +242,49 @@ void PrintStatement(const Statement* s, int depth) {
       break;
     case StatementKind::VariableDefinition:
       std::cout << "var ";
-      PrintExp(s->u.variable_definition.pat);
+      PrintExp(s->GetVariableDefinition().pat);
       std::cout << " = ";
-      PrintExp(s->u.variable_definition.init);
+      PrintExp(s->GetVariableDefinition().init);
       std::cout << ";";
       break;
     case StatementKind::ExpressionStatement:
-      PrintExp(s->u.exp);
+      PrintExp(s->GetExpression());
       std::cout << ";";
       break;
     case StatementKind::Assign:
-      PrintExp(s->u.assign.lhs);
+      PrintExp(s->GetAssign().lhs);
       std::cout << " = ";
-      PrintExp(s->u.assign.rhs);
+      PrintExp(s->GetAssign().rhs);
       std::cout << ";";
       break;
     case StatementKind::If:
       std::cout << "if (";
-      PrintExp(s->u.if_stmt.cond);
+      PrintExp(s->GetIf().cond);
       std::cout << ")" << std::endl;
-      PrintStatement(s->u.if_stmt.then_stmt, depth - 1);
+      PrintStatement(s->GetIf().then_stmt, depth - 1);
       std::cout << std::endl << "else" << std::endl;
-      PrintStatement(s->u.if_stmt.else_stmt, depth - 1);
+      PrintStatement(s->GetIf().else_stmt, depth - 1);
       break;
     case StatementKind::Return:
       std::cout << "return ";
-      PrintExp(s->u.return_stmt);
+      PrintExp(s->GetReturn());
       std::cout << ";";
       break;
     case StatementKind::Sequence:
-      PrintStatement(s->u.sequence.stmt, depth);
+      PrintStatement(s->GetSequence().stmt, depth);
       if (depth < 0 || depth > 1) {
         std::cout << std::endl;
       } else {
         std::cout << " ";
       }
-      PrintStatement(s->u.sequence.next, depth - 1);
+      PrintStatement(s->GetSequence().next, depth - 1);
       break;
     case StatementKind::Block:
       std::cout << "{";
       if (depth < 0 || depth > 1) {
         std::cout << std::endl;
       }
-      PrintStatement(s->u.block.stmt, depth);
+      PrintStatement(s->GetBlock().stmt, depth);
       if (depth < 0 || depth > 1) {
         std::cout << std::endl;
       }
@@ -232,19 +294,19 @@ void PrintStatement(const Statement* s, int depth) {
       }
       break;
     case StatementKind::Continuation:
-      std::cout << "continuation " << *s->u.continuation.continuation_variable
-                << " ";
+      std::cout << "continuation "
+                << *s->GetContinuation().continuation_variable << " ";
       if (depth < 0 || depth > 1) {
         std::cout << std::endl;
       }
-      PrintStatement(s->u.continuation.body, depth - 1);
+      PrintStatement(s->GetContinuation().body, depth - 1);
       if (depth < 0 || depth > 1) {
         std::cout << std::endl;
       }
       break;
     case StatementKind::Run:
       std::cout << "run ";
-      PrintExp(s->u.run.argument);
+      PrintExp(s->GetRun().argument);
       std::cout << ";";
       break;
     case StatementKind::Await:

executable_semantics/ast/statement.h

@@ -28,98 +28,126 @@ enum class StatementKind {
   Await,         // Pause execution of the continuation.
 };
 
+struct Statement;
+
+struct Assignment {
+  const Expression* lhs;
+  const Expression* rhs;
+};
+
+struct VariableDefinition {
+  const Expression* pat;
+  const Expression* init;
+};
+
+struct IfStatement {
+  const Expression* cond;
+  const Statement* then_stmt;
+  const Statement* else_stmt;
+};
+
+struct Sequence {
+  const Statement* stmt;
+  const Statement* next;
+};
+
+struct Block {
+  const Statement* stmt;
+};
+
+struct While {
+  const Expression* cond;
+  const Statement* body;
+};
+
+struct Match {
+  const Expression* exp;
+  std::list<std::pair<const Expression*, const Statement*>>* clauses;
+};
+
+struct Continuation {
+  std::string* continuation_variable;
+  const Statement* body;
+};
+
+struct Run {
+  const Expression* argument;
+};
+
 struct Statement {
+  // TODO: change Statement to a class and make all members private
   int line_num;
   StatementKind tag;
 
+  // Constructors
+  static auto MakeExpStmt(int line_num, const Expression* exp)
+      -> const Statement*;
+  static auto MakeAssign(int line_num, const Expression* lhs,
+                         const Expression* rhs) -> const Statement*;
+  static auto MakeVarDef(int line_num, const Expression* pat,
+                         const Expression* init) -> const Statement*;
+  static auto MakeIf(int line_num, const Expression* cond,
+                     const Statement* then_stmt, const Statement* else_stmt)
+      -> const Statement*;
+  static auto MakeReturn(int line_num, const Expression* e) -> const Statement*;
+  static auto MakeSeq(int line_num, const Statement* s1, const Statement* s2)
+      -> const Statement*;
+  static auto MakeBlock(int line_num, const Statement* s) -> const Statement*;
+  static auto MakeWhile(int line_num, const Expression* cond,
+                        const Statement* body) -> const Statement*;
+  static auto MakeBreak(int line_num) -> const Statement*;
+  static auto MakeContinue(int line_num) -> const Statement*;
+  static auto MakeMatch(
+      int line_num, const Expression* exp,
+      std::list<std::pair<const Expression*, const Statement*>>* clauses)
+      -> const Statement*;
+  // Returns an AST node for a continuation statement give its line number and
+  // contituent parts.
+  //
+  //     __continuation <continuation_variable> {
+  //       <body>
+  //     }
+  static auto MakeContinuation(int line_num, std::string continuation_variable,
+                               const Statement* body) -> const Statement*;
+  // Returns an AST node for a run statement give its line number and argument.
+  //
+  //     __run <argument>;
+  static auto MakeRun(int line_num, const Expression* argument)
+      -> const Statement*;
+  // Returns an AST node for an await statement give its line number.
+  //
+  //     __await;
+  static auto MakeAwait(int line_num) -> const Statement*;
+
+  // Access to the alternatives
+  const Expression* GetExpression() const;
+  Assignment GetAssign() const;
+  VariableDefinition GetVariableDefinition() const;
+  IfStatement GetIf() const;
+  const Expression* GetReturn() const;
+  Sequence GetSequence() const;
+  Block GetBlock() const;
+  While GetWhile() const;
+  Match GetMatch() const;
+  Continuation GetContinuation() const;
+  Run GetRun() const;
+
+ private:
   union {
     const Expression* exp;
-
-    struct {
-      const Expression* lhs;
-      const Expression* rhs;
-    } assign;
-
-    struct {
-      const Expression* pat;
-      const Expression* init;
-    } variable_definition;
-
-    struct {
-      const Expression* cond;
-      const Statement* then_stmt;
-      const Statement* else_stmt;
-    } if_stmt;
-
+    Assignment assign;
+    VariableDefinition variable_definition;
+    IfStatement if_stmt;
     const Expression* return_stmt;
-
-    struct {
-      const Statement* stmt;
-      const Statement* next;
-    } sequence;
-
-    struct {
-      const Statement* stmt;
-    } block;
-
-    struct {
-      const Expression* cond;
-      const Statement* body;
-    } while_stmt;
-
-    struct {
-      const Expression* exp;
-      std::list<std::pair<const Expression*, const Statement*>>* clauses;
-    } match_stmt;
-
-    struct {
-      std::string* continuation_variable;
-      const Statement* body;
-    } continuation;
-
-    struct {
-      const Expression* argument;
-    } run;
-
+    Sequence sequence;
+    Block block;
+    While while_stmt;
+    Match match_stmt;
+    Continuation continuation;
+    Run run;
   } u;
 };
 
-auto MakeExpStmt(int line_num, const Expression* exp) -> const Statement*;
-auto MakeAssign(int line_num, const Expression* lhs, const Expression* rhs)
-    -> const Statement*;
-auto MakeVarDef(int line_num, const Expression* pat, const Expression* init)
-    -> const Statement*;
-auto MakeIf(int line_num, const Expression* cond, const Statement* then_stmt,
-            const Statement* else_stmt) -> const Statement*;
-auto MakeReturn(int line_num, const Expression* e) -> const Statement*;
-auto MakeSeq(int line_num, const Statement* s1, const Statement* s2)
-    -> const Statement*;
-auto MakeBlock(int line_num, const Statement* s) -> const Statement*;
-auto MakeWhile(int line_num, const Expression* cond, const Statement* body)
-    -> const Statement*;
-auto MakeBreak(int line_num) -> const Statement*;
-auto MakeContinue(int line_num) -> const Statement*;
-auto MakeMatch(
-    int line_num, const Expression* exp,
-    std::list<std::pair<const Expression*, const Statement*>>* clauses)
-    -> const Statement*;
-// Returns an AST node for a continuation statement give its line number and
-// contituent parts.
-//
-//     __continuation <continuation_variable> {
-//       <body>
-//     }
-auto MakeContinuationStatement(int line_num, std::string continuation_variable,
-                               const Statement* body) -> const Statement*;
-// Returns an AST node for a run statement give its line number and argument.
-//
-//     __run <argument>;
-auto MakeRun(int line_num, const Expression* argument) -> const Statement*;
-// Returns an AST node for an await statement give its line number.
-//
-//     __await;
-auto MakeAwait(int line_num) -> const Statement*;
-
 void PrintStatement(const Statement*, int);
 
 }  // namespace Carbon