Convert Pattern and Expression to Ptr (#787)

Sorry about the big change, this is hard to split. ParenContents is used by both, templated, and expects the same pointer type. While I could duplicate ParenContents with some ExpressionParenContents or PatternParenContents, that seems a little kludgy versus a single large change handling both. The worst of it is that Expression is already pretty sweeping, Pattern is really just incrementally adding.

That said, I believe this includes a couple fixes I found with incorrect use of dyn_cast in typecheck.cpp (checked nullptr at the wrong step in 2 code locations). There's also a missing `*` in member.cpp this caught. I adjust passing of expressions for Return due to nullness (I felt adding another constructor was the best solution).

I add a `.Release()` to BisonWrap due to things like `$3.first` needing some way to work through BIsonWrap. I felt this was better than `operator->`, but feel free to comment if you prefer the other path (`.Release()` conveniently lets me do pair unwrapping, so it felt a better solution).

I do add a TODO to think about better Ptr-to-Ptr cast<> support too, though, as that doesn't work cleanly with LLVM's infra. But so far it seems to only come up in one spot, so I'm not prioritizing it.

executable_semantics/ast/expression.h

@@ -63,24 +63,24 @@ class Expression {
 // tuple otherwise.
 auto ExpressionFromParenContents(
     SourceLocation loc, const ParenContents<Expression>& paren_contents)
-    -> const Expression*;
+    -> Ptr<const Expression>;
 
 // Converts paren_contents to an Expression, interpreting the parentheses as
 // forming a tuple.
 auto TupleExpressionFromParenContents(
     SourceLocation loc, const ParenContents<Expression>& paren_contents)
-    -> const Expression*;
+    -> Ptr<const Expression>;
 
 // A FieldInitializer represents the initialization of a single tuple field.
 struct FieldInitializer {
-  FieldInitializer(std::string name, const Expression* expression)
+  FieldInitializer(std::string name, Ptr<const Expression> expression)
       : name(std::move(name)), expression(expression) {}
 
   // The field name. Cannot be empty.
   std::string name;
 
   // The expression that initializes the field.
-  const Expression* expression;
+  Ptr<const Expression> expression;
 };
 
 enum class Operator {
@@ -114,7 +114,8 @@ class IdentifierExpression : public Expression {
 class FieldAccessExpression : public Expression {
  public:
   explicit FieldAccessExpression(SourceLocation loc,
-                                 const Expression* aggregate, std::string field)
+                                 Ptr<const Expression> aggregate,
+                                 std::string field)
       : Expression(Kind::FieldAccessExpression, loc),
         aggregate(aggregate),
         field(std::move(field)) {}
@@ -123,18 +124,18 @@ class FieldAccessExpression : public Expression {
     return exp->Tag() == Kind::FieldAccessExpression;
   }
 
-  auto Aggregate() const -> const Expression* { return aggregate; }
+  auto Aggregate() const -> Ptr<const Expression> { return aggregate; }
   auto Field() const -> const std::string& { return field; }
 
  private:
-  const Expression* aggregate;
+  Ptr<const Expression> aggregate;
   std::string field;
 };
 
 class IndexExpression : public Expression {
  public:
-  explicit IndexExpression(SourceLocation loc, const Expression* aggregate,
-                           const Expression* offset)
+  explicit IndexExpression(SourceLocation loc, Ptr<const Expression> aggregate,
+                           Ptr<const Expression> offset)
       : Expression(Kind::IndexExpression, loc),
         aggregate(aggregate),
         offset(offset) {}
@@ -143,12 +144,12 @@ class IndexExpression : public Expression {
     return exp->Tag() == Kind::IndexExpression;
   }
 
-  auto Aggregate() const -> const Expression* { return aggregate; }
-  auto Offset() const -> const Expression* { return offset; }
+  auto Aggregate() const -> Ptr<const Expression> { return aggregate; }
+  auto Offset() const -> Ptr<const Expression> { return offset; }
 
  private:
-  const Expression* aggregate;
-  const Expression* offset;
+  Ptr<const Expression> aggregate;
+  Ptr<const Expression> offset;
 };
 
 class IntLiteral : public Expression {
@@ -226,8 +227,9 @@ class TupleLiteral : public Expression {
 
 class PrimitiveOperatorExpression : public Expression {
  public:
-  explicit PrimitiveOperatorExpression(SourceLocation loc, Operator op,
-                                       std::vector<const Expression*> arguments)
+  explicit PrimitiveOperatorExpression(
+      SourceLocation loc, Operator op,
+      std::vector<Ptr<const Expression>> arguments)
       : Expression(Kind::PrimitiveOperatorExpression, loc),
         op(op),
         arguments(std::move(arguments)) {}
@@ -237,19 +239,19 @@ class PrimitiveOperatorExpression : public Expression {
   }
 
   auto Op() const -> Operator { return op; }
-  auto Arguments() const -> const std::vector<const Expression*>& {
+  auto Arguments() const -> const std::vector<Ptr<const Expression>>& {
     return arguments;
   }
 
  private:
   Operator op;
-  std::vector<const Expression*> arguments;
+  std::vector<Ptr<const Expression>> arguments;
 };
 
 class CallExpression : public Expression {
  public:
-  explicit CallExpression(SourceLocation loc, const Expression* function,
-                          const Expression* argument)
+  explicit CallExpression(SourceLocation loc, Ptr<const Expression> function,
+                          Ptr<const Expression> argument)
       : Expression(Kind::CallExpression, loc),
         function(function),
         argument(argument) {}
@@ -258,18 +260,19 @@ class CallExpression : public Expression {
     return exp->Tag() == Kind::CallExpression;
   }
 
-  auto Function() const -> const Expression* { return function; }
-  auto Argument() const -> const Expression* { return argument; }
+  auto Function() const -> Ptr<const Expression> { return function; }
+  auto Argument() const -> Ptr<const Expression> { return argument; }
 
  private:
-  const Expression* function;
-  const Expression* argument;
+  Ptr<const Expression> function;
+  Ptr<const Expression> argument;
 };
 
 class FunctionTypeLiteral : public Expression {
  public:
-  explicit FunctionTypeLiteral(SourceLocation loc, const Expression* parameter,
-                               const Expression* return_type,
+  explicit FunctionTypeLiteral(SourceLocation loc,
+                               Ptr<const Expression> parameter,
+                               Ptr<const Expression> return_type,
                                bool is_omitted_return_type)
       : Expression(Kind::FunctionTypeLiteral, loc),
         parameter(parameter),
@@ -280,13 +283,13 @@ class FunctionTypeLiteral : public Expression {
     return exp->Tag() == Kind::FunctionTypeLiteral;
   }
 
-  auto Parameter() const -> const Expression* { return parameter; }
-  auto ReturnType() const -> const Expression* { return return_type; }
+  auto Parameter() const -> Ptr<const Expression> { return parameter; }
+  auto ReturnType() const -> Ptr<const Expression> { return return_type; }
   auto IsOmittedReturnType() const -> bool { return is_omitted_return_type; }
 
  private:
-  const Expression* parameter;
-  const Expression* return_type;
+  Ptr<const Expression> parameter;
+  Ptr<const Expression> return_type;
   bool is_omitted_return_type;
 };