Factor allocation interface out of Heap (#918)

This will enable `Action` to deallocate from the heap without creating a dependency cycle.

executable_semantics/interpreter/BUILD

@@ -75,11 +75,23 @@ cc_library(
     deps = [
         ":action_and_value",
         ":address",
+        ":heap_allocation_interface",
         "//common:ostream",
+        "//executable_semantics/ast:source_location",
+        "//executable_semantics/common:nonnull",
         "@llvm-project//llvm:Support",
     ],
 )
 
+cc_library(
+    name = "heap_allocation_interface",
+    hdrs = ["heap_allocation_interface.h"],
+    deps = [
+        ":address",
+        "//executable_semantics/common:nonnull",
+    ],
+)
+
 cc_library(
     name = "interpreter",
     srcs = [

executable_semantics/interpreter/heap.h

@@ -8,14 +8,16 @@
 #include <vector>
 
 #include "common/ostream.h"
+#include "executable_semantics/ast/source_location.h"
+#include "executable_semantics/common/nonnull.h"
 #include "executable_semantics/interpreter/address.h"
+#include "executable_semantics/interpreter/heap_allocation_interface.h"
 #include "executable_semantics/interpreter/value.h"
-#include "llvm/Support/Compiler.h"
 
 namespace Carbon {
 
 // A Heap represents the abstract machine's dynamically allocated memory.
-class Heap {
+class Heap : public HeapAllocationInterface {
  public:
   // Constructs an empty Heap.
   explicit Heap(Nonnull<Arena*> arena) : arena_(arena){};
@@ -34,10 +36,10 @@ class Heap {
              SourceLocation source_loc);
 
   // Put the given value on the heap and mark it as alive.
-  auto AllocateValue(Nonnull<const Value*> v) -> AllocationId;
+  auto AllocateValue(Nonnull<const Value*> v) -> AllocationId override;
 
   // Marks this allocation, and all of its sub-objects, as dead.
-  void Deallocate(AllocationId allocation);
+  void Deallocate(AllocationId allocation) override;
 
   // Print the value at the given allocation to the stream `out`.
   void PrintAllocation(AllocationId allocation, llvm::raw_ostream& out) const;

executable_semantics/interpreter/heap_allocation_interface.h

@@ -0,0 +1,36 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef EXECUTABLE_SEMANTICS_INTERPRETER_HEAP_ALLOCATION_INTERFACE_H_
+#define EXECUTABLE_SEMANTICS_INTERPRETER_HEAP_ALLOCATION_INTERFACE_H_
+
+#include "executable_semantics/common/nonnull.h"
+#include "executable_semantics/interpreter/address.h"
+
+namespace Carbon {
+
+class Value;
+
+// The allocation interface for Heap, factored out as an interface in order to
+// resolve a layering issue. No other class should derive from this.
+class HeapAllocationInterface {
+ public:
+  HeapAllocationInterface(const HeapAllocationInterface&) = delete;
+  auto operator=(const HeapAllocationInterface&)
+      -> HeapAllocationInterface& = delete;
+
+  // Put the given value on the heap and mark it as alive.
+  virtual auto AllocateValue(Nonnull<const Value*> v) -> AllocationId = 0;
+
+  // Marks this allocation, and all of its sub-objects, as dead.
+  virtual void Deallocate(AllocationId allocation) = 0;
+
+ protected:
+  HeapAllocationInterface() = default;
+  virtual ~HeapAllocationInterface() = default;
+};
+
+}  // namespace Carbon
+
+#endif  // EXECUTABLE_SEMANTICS_INTERPRETER_HEAP_ALLOCATION_INTERFACE_H_