diff --git a/spec/helpers/tree_helpers.cc b/spec/helpers/tree_helpers.cc
index 4b5885f4..e4ae4dab 100644
--- a/spec/helpers/tree_helpers.cc
+++ b/spec/helpers/tree_helpers.cc
@@ -41,6 +41,15 @@ bool operator==(const TSNode &left, const TSNode &right) {
   return ts_node_eq(left, right);
 }
 
+bool operator==(const std::vector<TSTree *> &vec, const TreeArray &array) {
+  if (vec.size() != array.size)
+    return false;
+  for (size_t i = 0; i < array.size; i++)
+    if (array.contents[i] != vec[i])
+      return false;
+  return true;
+}
+
 ostream &operator<<(ostream &stream, const TSLength &length) {
   return stream << "{chars:" << length.chars << ", bytes:" <<
     length.bytes << ", rows:" << length.rows << ", columns:" << length.columns << "}";
diff --git a/spec/helpers/tree_helpers.h b/spec/helpers/tree_helpers.h
index 6fca9e57..c151c9ba 100644
--- a/spec/helpers/tree_helpers.h
+++ b/spec/helpers/tree_helpers.h
@@ -11,5 +11,6 @@ std::ostream &operator<<(std::ostream &stream, const TSTree *tree);
 std::ostream &operator<<(std::ostream &stream, const TSNode &node);
 std::ostream &operator<<(std::ostream &stream, const TSLength &length);
 bool operator==(const TSNode &left, const TSNode &right);
+bool operator==(const std::vector<TSTree *> &right, const TreeArray &array);
 
 #endif  // HELPERS_TREE_HELPERS_H_
diff --git a/spec/runtime/stack_spec.cc b/spec/runtime/stack_spec.cc
index bf336f35..eda3442f 100644
--- a/spec/runtime/stack_spec.cc
+++ b/spec/runtime/stack_spec.cc
@@ -145,9 +145,7 @@ describe("Stack", [&]() {
       AssertThat(results.size, Equals<size_t>(1));
 
       StackPopResult result = results.contents[0];
-      AssertThat(result.trees.size, Equals<size_t>(2));
-      AssertThat(result.trees.contents[0], Equals(trees[1]));
-      AssertThat(result.trees.contents[1], Equals(trees[2]));
+      AssertThat(result.trees, Equals(vector<TSTree *>({ trees[1], trees[2] })));
       AssertThat(*ts_stack_head(stack, 0), Equals<StackEntry>({trees[0], stateA, tree_len}));
       free_pop_results(&results);
 
@@ -158,8 +156,7 @@ describe("Stack", [&]() {
       AssertThat(results.size, Equals<size_t>(1));
 
       result = results.contents[0];
-      AssertThat(result.trees.size, Equals<size_t>(1));
-      AssertThat(result.trees.contents[0], Equals(trees[0]));
+      AssertThat(result.trees, Equals(vector<TSTree *>({ trees[0] })));
       AssertThat(ts_stack_head(stack, 0), Equals<const StackEntry *>(nullptr));
 
       free_pop_results(&results);
@@ -172,10 +169,7 @@ describe("Stack", [&]() {
       AssertThat(results.size, Equals<size_t>(1));
 
       StackPopResult result = results.contents[0];
-      AssertThat(result.trees.size, Equals<size_t>(3));
-      AssertThat(result.trees.contents[0], Equals(trees[0]));
-      AssertThat(result.trees.contents[1], Equals(trees[1]));
-      AssertThat(result.trees.contents[2], Equals(trees[2]));
+      AssertThat(result.trees, Equals(vector<TSTree *>({ trees[0], trees[1], trees[2] })));
       AssertThat(ts_stack_head(stack, 0), Equals<const StackEntry *>(nullptr));
 
       free_pop_results(&results);
@@ -186,10 +180,7 @@ describe("Stack", [&]() {
       AssertThat(results.size, Equals<size_t>(1));
 
       StackPopResult result = results.contents[0];
-      AssertThat(result.trees.size, Equals<size_t>(3));
-      AssertThat(result.trees.contents[0], Equals(trees[0]));
-      AssertThat(result.trees.contents[1], Equals(trees[1]));
-      AssertThat(result.trees.contents[2], Equals(trees[2]));
+      AssertThat(result.trees, Equals(vector<TSTree *>({ trees[0], trees[1], trees[2] })));
 
       free_pop_results(&results);
     });
@@ -386,15 +377,11 @@ describe("Stack", [&]() {
         AssertThat(results.size, Equals<size_t>(2));
         StackPopResult pop1 = results.contents[0];
         AssertThat(pop1.head_index, Equals(0));
-        AssertThat(pop1.trees.size, Equals<size_t>(2));
-        AssertThat(pop1.trees.contents[0], Equals(trees[3]));
-        AssertThat(pop1.trees.contents[1], Equals(trees[6]));
+        AssertThat(pop1.trees, Equals(vector<TSTree *>({ trees[3], trees[6] })));
 
         StackPopResult pop2 = results.contents[1];
         AssertThat(pop2.head_index, Equals(1));
-        AssertThat(pop2.trees.size, Equals<size_t>(2));
-        AssertThat(pop2.trees.contents[0], Equals(trees[5]));
-        AssertThat(pop2.trees.contents[1], Equals(trees[6]));
+        AssertThat(pop2.trees, Equals(vector<TSTree *>({ trees[5], trees[6] })));
 
         AssertThat(ts_stack_head_count(stack), Equals(2));
         AssertThat(*ts_stack_head(stack, 0), Equals<StackEntry>({trees[2], stateC, tree_len * 3}));
@@ -445,15 +432,12 @@ describe("Stack", [&]() {
         AssertThat(results.size, Equals<size_t>(2));
         StackPopResult pop1 = results.contents[0];
         AssertThat(pop1.head_index, Equals(0));
-        AssertThat(pop1.trees.size, Equals<size_t>(2));
-        AssertThat(pop1.trees.contents[0], Equals(trees[6]));
-        AssertThat(pop1.trees.contents[1], Equals(trees[7]));
+        AssertThat(pop1.trees, Equals(vector<TSTree *>({ trees[6], trees[7] })));
 
         StackPopResult pop2 = results.contents[1];
         AssertThat(pop2.head_index, Equals(1));
-        AssertThat(pop2.trees.size, Equals<size_t>(2));
-        AssertThat(pop2.trees.contents[0], Equals(trees[6]));
-        AssertThat(pop2.trees.contents[1], Equals(trees[7]));
+        AssertThat(pop2.trees, Equals(vector<TSTree *>({ trees[6], trees[7] })));
+        AssertThat(pop2.trees.contents, Equals(pop1.trees.contents));
 
         free_pop_results(&results);
       });
@@ -473,9 +457,8 @@ describe("Stack", [&]() {
 
           AssertThat(results.size, Equals<size_t>(1));
           StackPopResult pop1 = results.contents[0];
-          AssertThat(pop1.trees.size, Equals<size_t>(3));
           AssertThat(pop1.head_index, Equals(0));
-          AssertThat(pop1.trees.contents[0], Equals(trees[2]));
+          AssertThat(pop1.trees, Equals(vector<TSTree *>({ trees[2], trees[3], trees[ 6] })));
 
           free_pop_results(&results);
         });
@@ -494,9 +477,8 @@ describe("Stack", [&]() {
 
           AssertThat(results.size, Equals<size_t>(1));
           StackPopResult pop1 = results.contents[0];
-          AssertThat(pop1.trees.size, Equals<size_t>(3));
           AssertThat(pop1.head_index, Equals(0));
-          AssertThat(pop1.trees.contents[0], Equals(trees[4]));
+          AssertThat(pop1.trees, Equals(vector<TSTree *>({ trees[4], trees[5], trees[6] })))
 
           free_pop_results(&results);
         });
@@ -548,9 +530,7 @@ describe("Stack", [&]() {
         StackPopResult pop1 = results.contents[0];
         AssertThat(ts_stack_top_tree(stack, 0), Equals(trees[3]));
         AssertThat(pop1.head_index, Equals(0));
-        AssertThat(pop1.trees.size, Equals<size_t>(2));
-        AssertThat(pop1.trees.contents[0], Equals(trees[8]));
-        AssertThat(pop1.trees.contents[1], Equals(trees[9]));
+        AssertThat(pop1.trees, Equals(vector<TSTree *>({ trees[8], trees[9] })))
 
         StackPopResult pop2 = results.contents[1];
         AssertThat(ts_stack_top_tree(stack, 1), Equals(trees[5]));
@@ -583,26 +563,17 @@ describe("Stack", [&]() {
         StackPopResult pop1 = results.contents[0];
         AssertThat(ts_stack_top_tree(stack, 0), Equals(trees[2]));
         AssertThat(pop1.head_index, Equals(0));
-        AssertThat(pop1.trees.size, Equals<size_t>(3));
-        AssertThat(pop1.trees.contents[0], Equals(trees[3]));
-        AssertThat(pop1.trees.contents[1], Equals(trees[8]));
-        AssertThat(pop1.trees.contents[2], Equals(trees[9]));
+        AssertThat(pop1.trees, Equals(vector<TSTree *>({ trees[3], trees[8], trees[9] })))
 
         StackPopResult pop2 = results.contents[1];
         AssertThat(ts_stack_top_tree(stack, 1), Equals(trees[4]));
         AssertThat(pop2.head_index, Equals(1));
-        AssertThat(pop2.trees.size, Equals<size_t>(3));
-        AssertThat(pop2.trees.contents[0], Equals(trees[5]));
-        AssertThat(pop2.trees.contents[1], Equals(trees[8]));
-        AssertThat(pop2.trees.contents[2], Equals(trees[9]));
+        AssertThat(pop2.trees, Equals(vector<TSTree *>({ trees[5], trees[8], trees[9] })))
 
         StackPopResult pop3 = results.contents[2];
         AssertThat(ts_stack_top_tree(stack, 2), Equals(trees[6]));
         AssertThat(pop3.head_index, Equals(2));
-        AssertThat(pop3.trees.size, Equals<size_t>(3));
-        AssertThat(pop3.trees.contents[0], Equals(trees[7]));
-        AssertThat(pop3.trees.contents[1], Equals(trees[8]));
-        AssertThat(pop3.trees.contents[2], Equals(trees[9]));
+        AssertThat(pop3.trees, Equals(vector<TSTree *>({ trees[7], trees[8], trees[9] })))
 
         free_pop_results(&results);
       });
diff --git a/src/runtime/stack.h b/src/runtime/stack.h
index d8a83dd1..450f334a 100644
--- a/src/runtime/stack.h
+++ b/src/runtime/stack.h
@@ -7,6 +7,7 @@ extern "C" {
 
 #include "tree_sitter/parser.h"
 #include "runtime/array.h"
+#include "runtime/tree.h"
 
 typedef struct Stack Stack;
 
@@ -16,8 +17,6 @@ typedef struct {
   TSLength position;
 } StackEntry;
 
-typedef Array(TSTree *) TreeArray;
-
 typedef struct {
   TreeArray trees;
   int head_index;
diff --git a/src/runtime/tree.h b/src/runtime/tree.h
index a41ee285..ae12b97f 100644
--- a/src/runtime/tree.h
+++ b/src/runtime/tree.h
@@ -8,6 +8,7 @@ extern "C" {
 #include <stdbool.h>
 #include "tree_sitter/parser.h"
 #include "runtime/length.h"
+#include "runtime/array.h"
 
 extern TSStateId TS_TREE_STATE_INDEPENDENT;
 extern TSStateId TS_TREE_STATE_ERROR;
@@ -42,6 +43,8 @@ struct TSTree {
   bool has_changes : 1;
 };
 
+typedef Array(TSTree *) TreeArray;
+
 TSTree *ts_tree_make_leaf(TSSymbol, TSLength, TSLength, TSSymbolMetadata);
 TSTree *ts_tree_make_node(TSSymbol, size_t, TSTree **, TSSymbolMetadata);
 TSTree *ts_tree_make_copy(TSTree *child);