Revert to handling Expression by const pointer (#616)

This reverts the bulk of #606, #607, and #611, as well as parts of #588, #605, and #614.

executable_semantics/ast/declaration.cpp

@@ -22,7 +22,7 @@ void ChoiceDeclaration::Print() const {
   std::cout << "choice " << name << " {" << std::endl;
   for (const auto& [name, signature] : alternatives) {
     std::cout << "alt " << name << " ";
-    PrintExp(&signature);
+    PrintExp(signature);
     std::cout << ";" << std::endl;
   }
   std::cout << "}" << std::endl;

executable_semantics/ast/declaration.h

@@ -137,10 +137,11 @@ struct StructDeclaration {
 struct ChoiceDeclaration {
   int line_num;
   std::string name;
-  std::list<std::pair<std::string, Expression>> alternatives;
+  std::list<std::pair<std::string, const Expression*>> alternatives;
 
-  ChoiceDeclaration(int line_num, std::string name,
-                    std::list<std::pair<std::string, Expression>> alternatives)
+  ChoiceDeclaration(
+      int line_num, std::string name,
+      std::list<std::pair<std::string, const Expression*>> alternatives)
       : line_num(line_num), name(name), alternatives(std::move(alternatives)) {}
 
   void Print() const;

executable_semantics/ast/expression.cpp

@@ -84,12 +84,11 @@ auto Expression::MakeContinuationType(int line_num) -> const Expression* {
   return type;
 }
 
-auto Expression::MakeFunType(int line_num, Expression param, Expression ret)
-    -> const Expression* {
+auto Expression::MakeFunType(int line_num, const Expression* param,
+                             const Expression* ret) -> const Expression* {
   auto* t = new Expression();
   t->line_num = line_num;
-  t->value = FunctionType(
-      {.parameter = std::move(param), .return_type = std::move(ret)});
+  t->value = FunctionType({.parameter = param, .return_type = ret});
   return t;
 }
 
@@ -100,11 +99,11 @@ auto Expression::MakeVar(int line_num, std::string var) -> const Expression* {
   return v;
 }
 
-auto Expression::MakeVarPat(int line_num, std::string var, 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->value = PatternVariable({.name = std::move(var), .type = std::move(type)});
+  v->value = PatternVariable({.name = std::move(var), .type = type});
   return v;
 }
 
@@ -123,35 +122,36 @@ auto Expression::MakeBool(int line_num, bool b) -> const Expression* {
 }
 
 auto Expression::MakeOp(int line_num, enum Operator op,
-                        std::vector<Expression> args) -> const Expression* {
+                        std::vector<const Expression*> args)
+    -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
   e->value = PrimitiveOperator({.op = op, .arguments = std::move(args)});
   return e;
 }
 
-auto Expression::MakeUnOp(int line_num, enum Operator op, 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;
-  e->value = PrimitiveOperator({.op = op, .arguments = {std::move(arg)}});
+  e->value = PrimitiveOperator({.op = op, .arguments = {arg}});
   return e;
 }
 
-auto Expression::MakeBinOp(int line_num, enum Operator op, Expression arg1,
-                           Expression arg2) -> const Expression* {
-  auto* e = new Expression();
-  e->line_num = line_num;
-  e->value = PrimitiveOperator(
-      {.op = op, .arguments = {std::move(arg1), std::move(arg2)}});
-  return e;
-}
-
-auto Expression::MakeCall(int line_num, Expression fun, Expression arg)
+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->value = Call({.function = std::move(fun), .argument = std::move(arg)});
+  e->value = PrimitiveOperator({.op = op, .arguments = {arg1, arg2}});
+  return e;
+}
+
+auto Expression::MakeCall(int line_num, const Expression* fun,
+                          const Expression* arg) -> const Expression* {
+  auto* e = new Expression();
+  e->line_num = line_num;
+  e->value = Call({.function = fun, .argument = arg});
   return e;
 }
 
@@ -159,7 +159,7 @@ auto Expression::MakeGetField(int line_num, const Expression* exp,
                               std::string field) -> const Expression* {
   auto* e = new Expression();
   e->line_num = line_num;
-  e->value = FieldAccess({.aggregate = *exp, .field = std::move(field)});
+  e->value = FieldAccess({.aggregate = exp, .field = std::move(field)});
   return e;
 }
 
@@ -187,11 +187,11 @@ auto Expression::MakeTuple(int line_num, std::vector<FieldInitializer> args)
   return e;
 }
 
-auto Expression::MakeIndex(int line_num, Expression exp, 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->value = Index({.aggregate = std::move(exp), .offset = std::move(i)});
+  e->value = Index({.aggregate = exp, .offset = i});
   return e;
 }
 
@@ -231,20 +231,20 @@ static void PrintFields(const std::vector<FieldInitializer>& fields) {
       std::cout << ", ";
     }
     std::cout << iter->name << " = ";
-    PrintExp(iter->expression.GetPointer());
+    PrintExp(iter->expression);
   }
 }
 
 void PrintExp(const Expression* e) {
   switch (e->tag()) {
     case ExpressionKind::Index:
-      PrintExp(e->GetIndex().aggregate.GetPointer());
+      PrintExp(e->GetIndex().aggregate);
       std::cout << "[";
-      PrintExp(e->GetIndex().offset.GetPointer());
+      PrintExp(e->GetIndex().offset);
       std::cout << "]";
       break;
     case ExpressionKind::GetField:
-      PrintExp(e->GetFieldAccess().aggregate.GetPointer());
+      PrintExp(e->GetFieldAccess().aggregate);
       std::cout << ".";
       std::cout << e->GetFieldAccess().field;
       break;
@@ -269,15 +269,15 @@ void PrintExp(const Expression* e) {
         PrintOp(op.op);
         std::cout << " ";
         auto iter = op.arguments.begin();
-        PrintExp(&*iter);
+        PrintExp(*iter);
       } else if (op.arguments.size() == 2) {
         auto iter = op.arguments.begin();
-        PrintExp(&*iter);
+        PrintExp(*iter);
         std::cout << " ";
         PrintOp(op.op);
         std::cout << " ";
         ++iter;
-        PrintExp(&*iter);
+        PrintExp(*iter);
       }
       std::cout << ")";
       break;
@@ -286,17 +286,17 @@ void PrintExp(const Expression* e) {
       std::cout << e->GetVariable().name;
       break;
     case ExpressionKind::PatternVariable:
-      PrintExp(e->GetPatternVariable().type.GetPointer());
+      PrintExp(e->GetPatternVariable().type);
       std::cout << ": ";
       std::cout << e->GetPatternVariable().name;
       break;
     case ExpressionKind::Call:
-      PrintExp(e->GetCall().function.GetPointer());
+      PrintExp(e->GetCall().function);
       if (e->GetCall().argument->tag() == ExpressionKind::Tuple) {
-        PrintExp(e->GetCall().argument.GetPointer());
+        PrintExp(e->GetCall().argument);
       } else {
         std::cout << "(";
-        PrintExp(e->GetCall().argument.GetPointer());
+        PrintExp(e->GetCall().argument);
         std::cout << ")";
       }
       break;
@@ -317,9 +317,9 @@ void PrintExp(const Expression* e) {
       break;
     case ExpressionKind::FunctionT:
       std::cout << "fn ";
-      PrintExp(e->GetFunctionType().parameter.GetPointer());
+      PrintExp(e->GetFunctionType().parameter);
       std::cout << " -> ";
-      PrintExp(e->GetFunctionType().return_type.GetPointer());
+      PrintExp(e->GetFunctionType().return_type);
       break;
   }
 }

executable_semantics/ast/expression.h

@@ -9,8 +9,6 @@
 #include <variant>
 #include <vector>
 
-#include "common/indirect_value.h"
-
 namespace Carbon {
 
 struct Expression;
@@ -21,7 +19,7 @@ struct FieldInitializer {
   std::string name;
 
   // The expression that initializes the field.
-  IndirectValue<Expression> expression;
+  const Expression* expression;
 };
 
 enum class ExpressionKind {
@@ -64,20 +62,20 @@ struct Variable {
 
 struct FieldAccess {
   static constexpr ExpressionKind Kind = ExpressionKind::GetField;
-  IndirectValue<Expression> aggregate;
+  const Expression* aggregate;
   std::string field;
 };
 
 struct Index {
   static constexpr ExpressionKind Kind = ExpressionKind::Index;
-  IndirectValue<Expression> aggregate;
-  IndirectValue<Expression> offset;
+  const Expression* aggregate;
+  const Expression* offset;
 };
 
 struct PatternVariable {
   static constexpr ExpressionKind Kind = ExpressionKind::PatternVariable;
   std::string name;
-  IndirectValue<Expression> type;
+  const Expression* type;
 };
 
 struct IntLiteral {
@@ -98,19 +96,19 @@ struct Tuple {
 struct PrimitiveOperator {
   static constexpr ExpressionKind Kind = ExpressionKind::PrimitiveOp;
   Operator op;
-  std::vector<Expression> arguments;
+  std::vector<const Expression*> arguments;
 };
 
 struct Call {
   static constexpr ExpressionKind Kind = ExpressionKind::Call;
-  IndirectValue<Expression> function;
-  IndirectValue<Expression> argument;
+  const Expression* function;
+  const Expression* argument;
 };
 
 struct FunctionType {
   static constexpr ExpressionKind Kind = ExpressionKind::FunctionT;
-  IndirectValue<Expression> parameter;
-  IndirectValue<Expression> return_type;
+  const Expression* parameter;
+  const Expression* return_type;
 };
 
 struct AutoT {
@@ -138,29 +136,29 @@ struct Expression {
   inline auto tag() const -> ExpressionKind;
 
   static auto MakeVar(int line_num, std::string var) -> const Expression*;
-  static auto MakeVarPat(int line_num, std::string var, Expression type)
+  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<Expression> args)
-      -> const Expression*;
-  static auto MakeUnOp(int line_num, enum Operator op, Expression arg)
-      -> const Expression*;
-  static auto MakeBinOp(int line_num, enum Operator op, Expression arg1,
-                        Expression arg2) -> const Expression*;
-  static auto MakeCall(int line_num, Expression fun, Expression arg)
+  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 MakeIndex(int line_num, Expression exp, Expression i)
-      -> 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, Expression param, Expression ret)
-      -> 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*;
 

executable_semantics/ast/function_definition.cpp

@@ -8,23 +8,23 @@
 
 namespace Carbon {
 
-auto MakeFunDef(int line_num, std::string name, Expression ret_type,
-                Expression param_pattern, const Statement* body)
+auto MakeFunDef(int line_num, std::string name, const Expression* ret_type,
+                const Expression* param_pattern, const Statement* body)
     -> FunctionDefinition {
   FunctionDefinition f;
   f.line_num = line_num;
   f.name = std::move(name);
-  f.return_type = std::move(ret_type);
-  f.param_pattern = std::move(param_pattern);
+  f.return_type = ret_type;
+  f.param_pattern = param_pattern;
   f.body = body;
   return f;
 }
 
 void PrintFunDefDepth(const FunctionDefinition& f, int depth) {
   std::cout << "fn " << f.name << " ";
-  PrintExp(&f.param_pattern);
+  PrintExp(f.param_pattern);
   std::cout << " -> ";
-  PrintExp(&f.return_type);
+  PrintExp(f.return_type);
   if (f.body) {
     std::cout << " {" << std::endl;
     PrintStatement(f.body, depth);

executable_semantics/ast/function_definition.h

@@ -13,13 +13,14 @@ namespace Carbon {
 struct FunctionDefinition {
   int line_num;
   std::string name;
-  Expression param_pattern;
-  Expression return_type;
+  const Expression* param_pattern;
+  const Expression* return_type;
   const Statement* body;
 };
 
-auto MakeFunDef(int line_num, std::string name, Expression ret_type,
-                Expression param, const Statement* body) -> FunctionDefinition;
+auto MakeFunDef(int line_num, std::string name, const Expression* ret_type,
+                const Expression* param, const Statement* body)
+    -> FunctionDefinition;
 void PrintFunDef(const FunctionDefinition&);
 void PrintFunDefDepth(const FunctionDefinition&, int);
 

executable_semantics/ast/statement.cpp

@@ -65,52 +65,53 @@ Run Statement::GetRun() const {
   return u.run;
 }
 
-auto Statement::MakeExpStmt(int line_num, Expression exp) -> const Statement* {
+auto Statement::MakeExpStmt(int line_num, const Expression* exp)
+    -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::ExpressionStatement;
-  s->u.exp = new Expression(std::move(exp));
+  s->u.exp = exp;
   return s;
 }
 
-auto Statement::MakeAssign(int line_num, Expression lhs, 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;
-  s->u.assign.lhs = new Expression(std::move(lhs));
-  s->u.assign.rhs = new Expression(std::move(rhs));
+  s->u.assign.lhs = lhs;
+  s->u.assign.rhs = rhs;
   return s;
 }
 
-auto Statement::MakeVarDef(int line_num, Expression pat, 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;
-  s->u.variable_definition.pat = new Expression(std::move(pat));
-  s->u.variable_definition.init = new Expression(std::move(init));
+  s->u.variable_definition.pat = pat;
+  s->u.variable_definition.init = init;
   return s;
 }
 
-auto Statement::MakeIf(int line_num, Expression cond,
+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;
-  s->u.if_stmt.cond = new Expression(std::move(cond));
+  s->u.if_stmt.cond = cond;
   s->u.if_stmt.then_stmt = then_stmt;
   s->u.if_stmt.else_stmt = else_stmt;
   return s;
 }
 
-auto Statement::MakeWhile(int line_num, 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;
-  s->u.while_stmt.cond = new Expression(std::move(cond));
+  s->u.while_stmt.cond = cond;
   s->u.while_stmt.body = body;
   return s;
 }
@@ -129,11 +130,12 @@ auto Statement::MakeContinue(int line_num) -> const Statement* {
   return s;
 }
 
-auto Statement::MakeReturn(int line_num, 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;
-  s->u.return_stmt = new Expression(std::move(e));
+  s->u.return_stmt = e;
   return s;
 }
 
@@ -157,13 +159,13 @@ auto Statement::MakeBlock(int line_num, const Statement* stmt)
 }
 
 auto Statement::MakeMatch(
-    int line_num, Expression exp,
+    int line_num, const Expression* exp,
     std::list<std::pair<const Expression*, const Statement*>>* clauses)
     -> const Statement* {
   auto* s = new Statement();
   s->line_num = line_num;
   s->tag = StatementKind::Match;
-  s->u.match_stmt.exp = new Expression(std::move(exp));
+  s->u.match_stmt.exp = exp;
   s->u.match_stmt.clauses = clauses;
   return s;
 }
@@ -183,11 +185,12 @@ auto Statement::MakeContinuation(int line_num,
 }
 
 // Returns an AST node for a run statement give its line number and argument.
-auto Statement::MakeRun(int line_num, 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;
-  run->u.run.argument = new Expression(std::move(argument));
+  run->u.run.argument = argument;
   return run;
 }
 

executable_semantics/ast/statement.h

@@ -80,23 +80,25 @@ struct Statement {
   StatementKind tag;
 
   // Constructors
-  static auto MakeExpStmt(int line_num, Expression exp) -> const Statement*;
-  static auto MakeAssign(int line_num, Expression lhs, Expression rhs)
+  static auto MakeExpStmt(int line_num, const Expression* exp)
       -> const Statement*;
-  static auto MakeVarDef(int line_num, Expression pat, Expression init)
+  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 MakeIf(int line_num, Expression cond, const Statement* then_stmt,
-                     const Statement* else_stmt) -> const Statement*;
-  static auto MakeReturn(int line_num, Expression e) -> 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, Expression cond, const Statement* body)
-      -> 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, Expression exp,
+      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
@@ -110,7 +112,8 @@ struct Statement {
   // Returns an AST node for a run statement give its line number and argument.
   //
   //     __run <argument>;
-  static auto MakeRun(int line_num, Expression argument) -> const Statement*;
+  static auto MakeRun(int line_num, const Expression* argument)
+      -> const Statement*;
   // Returns an AST node for an await statement give its line number.
   //
   //     __await;