Switch FunctionDefinition to a class (#852)

Splitting out the task from #849

executable_semantics/ast/declaration.h

@@ -61,7 +61,7 @@ class Declaration {
 class FunctionDeclaration : public Declaration {
  public:
   FunctionDeclaration(Nonnull<const FunctionDefinition*> definition)
-      : Declaration(Kind::FunctionDeclaration, definition->source_location),
+      : Declaration(Kind::FunctionDeclaration, definition->source_loc()),
         definition(definition) {}
 
   static auto classof(const Declaration* decl) -> bool {

executable_semantics/ast/function_definition.cpp

@@ -7,11 +7,11 @@
 namespace Carbon {
 
 void FunctionDefinition::PrintDepth(int depth, llvm::raw_ostream& out) const {
-  out << "fn " << name << " ";
-  if (deduced_parameters.size() > 0) {
+  out << "fn " << name_ << " ";
+  if (!deduced_parameters_.empty()) {
     out << "[";
     unsigned int i = 0;
-    for (const auto& deduced : deduced_parameters) {
+    for (const auto& deduced : deduced_parameters_) {
       if (i != 0) {
         out << ", ";
       }
@@ -21,13 +21,13 @@ void FunctionDefinition::PrintDepth(int depth, llvm::raw_ostream& out) const {
     }
     out << "]";
   }
-  out << *param_pattern;
-  if (!is_omitted_return_type) {
-    out << " -> " << *return_type;
+  out << *param_pattern_;
+  if (!is_omitted_return_type_) {
+    out << " -> " << *return_type_;
   }
-  if (body) {
+  if (body_) {
     out << " {\n";
-    (*body)->PrintDepth(depth, out);
+    (*body_)->PrintDepth(depth, out);
     out << "\n}\n";
   } else {
     out << ";\n";

executable_semantics/ast/function_definition.h

@@ -10,6 +10,7 @@
 #include "executable_semantics/ast/pattern.h"
 #include "executable_semantics/ast/source_location.h"
 #include "executable_semantics/ast/statement.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Compiler.h"
 
 namespace Carbon {
@@ -21,32 +22,48 @@ struct GenericBinding {
   Nonnull<const Expression*> type;
 };
 
-struct FunctionDefinition {
-  FunctionDefinition(SourceLocation source_location, std::string name,
+class FunctionDefinition {
+ public:
+  FunctionDefinition(SourceLocation source_loc, std::string name,
                      std::vector<GenericBinding> deduced_params,
                      Nonnull<const TuplePattern*> param_pattern,
                      Nonnull<const Pattern*> return_type,
                      bool is_omitted_return_type,
                      std::optional<Nonnull<const Statement*>> body)
-      : source_location(source_location),
-        name(std::move(name)),
-        deduced_parameters(deduced_params),
-        param_pattern(param_pattern),
-        return_type(return_type),
-        is_omitted_return_type(is_omitted_return_type),
-        body(body) {}
+      : source_loc_(source_loc),
+        name_(std::move(name)),
+        deduced_parameters_(deduced_params),
+        param_pattern_(param_pattern),
+        return_type_(return_type),
+        is_omitted_return_type_(is_omitted_return_type),
+        body_(body) {}
 
   void Print(llvm::raw_ostream& out) const { PrintDepth(-1, out); }
   void PrintDepth(int depth, llvm::raw_ostream& out) const;
   LLVM_DUMP_METHOD void Dump() const { Print(llvm::errs()); }
 
-  SourceLocation source_location;
-  std::string name;
-  std::vector<GenericBinding> deduced_parameters;
-  Nonnull<const TuplePattern*> param_pattern;
-  Nonnull<const Pattern*> return_type;
-  bool is_omitted_return_type;
-  std::optional<Nonnull<const Statement*>> body;
+  auto source_loc() const -> SourceLocation { return source_loc_; }
+  auto name() const -> const std::string& { return name_; }
+  auto deduced_parameters() const -> llvm::ArrayRef<GenericBinding> {
+    return deduced_parameters_;
+  }
+  auto param_pattern() const -> const TuplePattern& { return *param_pattern_; }
+  auto return_type() const -> const Pattern& { return *return_type_; }
+  auto is_omitted_return_type() const -> bool {
+    return is_omitted_return_type_;
+  }
+  auto body() const -> std::optional<Nonnull<const Statement*>> {
+    return body_;
+  }
+
+ private:
+  SourceLocation source_loc_;
+  std::string name_;
+  std::vector<GenericBinding> deduced_parameters_;
+  Nonnull<const TuplePattern*> param_pattern_;
+  Nonnull<const Pattern*> return_type_;
+  bool is_omitted_return_type_;
+  std::optional<Nonnull<const Statement*>> body_;
 };
 
 }  // namespace Carbon