Drop release functions from callback structs

The caller can just as easily take care of the cleanup explicitly

spec/runtime/document_spec.cc

@@ -90,7 +90,7 @@ describe("Document", [&]() {
     });
 
     it("allows the debugger to be retrieved later", [&]() {
-      AssertThat(ts_document_get_debugger(doc).data, Equals(debugger));
+      AssertThat(ts_document_get_debugger(doc).payload, Equals(debugger));
     });
 
     describe("disabling debugging", [&]() {
@@ -102,10 +102,6 @@ describe("Document", [&]() {
         ts_document_set_input_string(doc, "[1, 2]");
         AssertThat(debugger->messages, IsEmpty());
       });
-
-      it("releases the old debugger", [&]() {
-        AssertThat(debugger->release_call_count, Equals<size_t>(1));
-      });
     });
   });
 });

spec/runtime/helpers/log_debugger.cc

@@ -14,8 +14,7 @@ static void log_debug(void *data, TSDebugType type, const char *msg) {
 
 TSDebugger log_debugger_make() {
   TSDebugger result;
-  result.data = NULL;
+  result.payload = NULL;
   result.debug_fn = log_debug;
-  result.release_fn = NULL;
   return result;
 }

spec/runtime/helpers/spy_debugger.cc

@@ -10,16 +10,10 @@ static void spy_debug(void *data, TSDebugType type, const char *msg) {
   debugger->messages.push_back(msg);
 }
 
-static void spy_release(void *data) {
-  SpyDebugger *debugger = static_cast<SpyDebugger *>(data);
-  debugger->release_call_count++;
-}
-
 TSDebugger SpyDebugger::debugger() {
   TSDebugger result;
-  result.data = (void *)this;
+  result.payload = (void *)this;
   result.debug_fn = spy_debug;
-  result.release_fn = spy_release;
   return result;
 }
 

spec/runtime/helpers/spy_debugger.h

@@ -9,10 +9,7 @@ class SpyDebugger {
  public:
   void clear();
   TSDebugger debugger();
-
   std::vector<std::string> messages;
-  size_t release_call_count;
 };
 
 #endif  // HELPERS_SPY_DEBUGGER_H_
-

spec/runtime/helpers/spy_input.cc

@@ -80,10 +80,9 @@ int SpyInput::seek(size_t pos) {
 
 TSInput SpyInput::input() {
   TSInput result;
-  result.data = this;
+  result.payload = this;
   result.seek_fn = spy_seek;
   result.read_fn = spy_read;
-  result.release_fn = nullptr;
   return result;
 }
 

src/runtime/debugger.h

@@ -8,7 +8,7 @@ extern "C" {
 #include "tree_sitter/runtime.h"
 
 static inline TSDebugger ts_debugger_null() {
-  TSDebugger debugger = { 0, 0, 0 };
+  TSDebugger debugger = { 0, 0 };
   return debugger;
 }
 

src/runtime/document.c

@@ -14,8 +14,6 @@ TSDocument *ts_document_make() {
 
 void ts_document_free(TSDocument *document) {
   ts_parser_destroy(&document->parser);
-  if (document->input.release_fn)
-    document->input.release_fn(document->input.data);
   if (document->tree)
     ts_tree_release(document->tree);
   free(document);

src/runtime/lexer.c

@@ -9,7 +9,7 @@
 #define DEBUG(...)                                                    \
   if (lexer->debugger.debug_fn) {                                     \
     snprintf(lexer->debug_buffer, TS_DEBUG_BUFFER_SIZE, __VA_ARGS__); \
-    lexer->debugger.debug_fn(lexer->debugger.data, TSDebugTypeLex,    \
+    lexer->debugger.debug_fn(lexer->debugger.payload, TSDebugTypeLex,    \
                              lexer->debug_buffer);                    \
   }
 
@@ -24,10 +24,10 @@ static const char *empty_chunk = "";
 static void ts_lexer__get_chunk(TSLexer *lexer) {
   TSInput input = lexer->input;
   if (lexer->current_position.bytes != lexer->chunk_start + lexer->chunk_size)
-    input.seek_fn(input.data, lexer->current_position);
+    input.seek_fn(input.payload, lexer->current_position);
 
   lexer->chunk_start = lexer->current_position.bytes;
-  lexer->chunk = input.read_fn(input.data, &lexer->chunk_size);
+  lexer->chunk = input.read_fn(input.payload, &lexer->chunk_size);
   if (!lexer->chunk_size)
     lexer->chunk = empty_chunk;
 }

src/runtime/parser.c

@@ -17,7 +17,7 @@
 #define DEBUG(...)                                                           \
   if (parser->lexer.debugger.debug_fn) {                                     \
     snprintf(parser->lexer.debug_buffer, TS_DEBUG_BUFFER_SIZE, __VA_ARGS__); \
-    parser->lexer.debugger.debug_fn(parser->lexer.debugger.data,             \
+    parser->lexer.debugger.debug_fn(parser->lexer.debugger.payload,          \
                                     TSDebugTypeParse,                        \
                                     parser->lexer.debug_buffer);             \
   }
@@ -424,12 +424,8 @@ TSParser ts_parser_make() {
 void ts_parser_destroy(TSParser *parser) {
   ts_parse_stack_delete(parser->stack);
   ts_stack_delete(&parser->right_stack);
-
   if (parser->lookahead)
     ts_tree_release(parser->lookahead);
-
-  if (parser->lexer.debugger.release_fn)
-    parser->lexer.debugger.release_fn(parser->lexer.debugger.data);
 }
 
 TSDebugger ts_parser_get_debugger(const TSParser *parser) {
@@ -437,8 +433,6 @@ TSDebugger ts_parser_get_debugger(const TSParser *parser) {
 }
 
 void ts_parser_set_debugger(TSParser *parser, TSDebugger debugger) {
-  if (parser->lexer.debugger.release_fn)
-    parser->lexer.debugger.release_fn(parser->lexer.debugger.data);
   parser->lexer.debugger = debugger;
 }
 

src/runtime/string_input.c

@@ -7,31 +7,32 @@ typedef struct {
   size_t length;
 } TSStringInput;
 
-const char *ts_string_input_read(void *d, size_t *bytes_read) {
-  TSStringInput *data = (TSStringInput *)d;
-  if (data->position >= data->length) {
+const char *ts_string_input_read(void *payload, size_t *bytes_read) {
+  TSStringInput *input = (TSStringInput *)payload;
+  if (input->position >= input->length) {
     *bytes_read = 0;
     return "";
   }
-  size_t previous_position = data->position;
-  data->position = data->length;
-  *bytes_read = data->position - previous_position;
-  return data->string + previous_position;
+  size_t previous_position = input->position;
+  input->position = input->length;
+  *bytes_read = input->position - previous_position;
+  return input->string + previous_position;
 }
 
-int ts_string_input_seek(void *d, TSLength position) {
-  TSStringInput *data = (TSStringInput *)d;
-  data->position = position.bytes;
-  return (position.bytes < data->length);
+int ts_string_input_seek(void *payload, TSLength position) {
+  TSStringInput *input = (TSStringInput *)payload;
+  input->position = position.bytes;
+  return (position.bytes < input->length);
 }
 
 TSInput ts_string_input_make(const char *string) {
-  TSStringInput *data = malloc(sizeof(TSStringInput));
-  data->string = string;
-  data->position = 0;
-  data->length = strlen(string);
-  return (TSInput){.data = (void *)data,
-                   .read_fn = ts_string_input_read,
-                   .seek_fn = ts_string_input_seek,
-                   .release_fn = free };
+  TSStringInput *input = malloc(sizeof(TSStringInput));
+  input->string = string;
+  input->position = 0;
+  input->length = strlen(string);
+  return (TSInput){
+    .payload = input,
+    .read_fn = ts_string_input_read,
+    .seek_fn = ts_string_input_seek,
+  };
 }