Rename ts_document_set_debugger -> ts_document_set_logger

include/tree_sitter/parser.h

@@ -43,7 +43,7 @@ typedef struct TSLexer {
   TSSymbol result_symbol;
 
   TSInput input;
-  TSDebugger debugger;
+  TSLogger logger;
   char debug_buffer[TS_DEBUG_BUFFER_SIZE];
 } TSLexer;
 

include/tree_sitter/runtime.h

@@ -25,14 +25,14 @@ typedef struct {
 } TSInput;
 
 typedef enum {
-  TSDebugTypeParse,
-  TSDebugTypeLex,
-} TSDebugType;
+  TSLogTypeParse,
+  TSLogTypeLex,
+} TSLogType;
 
 typedef struct {
   void *payload;
-  void (*debug_fn)(void *payload, TSDebugType, const char *);
-} TSDebugger;
+  void (*log)(void *payload, TSLogType, const char *);
+} TSLogger;
 
 typedef struct {
   size_t position;
@@ -89,8 +89,8 @@ void ts_document_set_language(TSDocument *, const TSLanguage *);
 TSInput ts_document_input(TSDocument *);
 void ts_document_set_input(TSDocument *, TSInput);
 void ts_document_set_input_string(TSDocument *, const char *);
-TSDebugger ts_document_debugger(const TSDocument *);
-void ts_document_set_debugger(TSDocument *, TSDebugger);
+TSLogger ts_document_logger(const TSDocument *);
+void ts_document_set_logger(TSDocument *, TSLogger);
 void ts_document_print_debugging_graphs(TSDocument *, bool);
 void ts_document_edit(TSDocument *, TSInputEdit);
 int ts_document_parse(TSDocument *);

spec/helpers/log_debugger.h

@@ -1,8 +0,0 @@
-#ifndef HELPERS_LOG_DEBUGGER_H_
-#define HELPERS_LOG_DEBUGGER_H_
-
-#include "tree_sitter/runtime.h"
-
-TSDebugger log_debugger_make(bool include_lexing);
-
-#endif  // HELPERS_LOG_DEBUGGER_H_

spec/helpers/spy_debugger.cc

@@ -1,22 +0,0 @@
-#include "helpers/spy_debugger.h"
-#include <string>
-#include <vector>
-
-using std::string;
-using std::vector;
-
-static void spy_debug(void *data, TSDebugType type, const char *msg) {
-  SpyDebugger *debugger = static_cast<SpyDebugger *>(data);
-  debugger->messages.push_back(msg);
-}
-
-TSDebugger SpyDebugger::debugger() {
-  TSDebugger result;
-  result.payload = (void *)this;
-  result.debug_fn = spy_debug;
-  return result;
-}
-
-void SpyDebugger::clear() {
-  messages.clear();
-}

spec/helpers/spy_logger.cc

@@ -0,0 +1,22 @@
+#include "helpers/spy_logger.h"
+#include <string>
+#include <vector>
+
+using std::string;
+using std::vector;
+
+static void spy_log(void *data, TSLogType type, const char *msg) {
+  SpyLogger *logger = static_cast<SpyLogger *>(data);
+  logger->messages.push_back(msg);
+}
+
+TSLogger SpyLogger::logger() {
+  TSLogger result;
+  result.payload = (void *)this;
+  result.log = spy_log;
+  return result;
+}
+
+void SpyLogger::clear() {
+  messages.clear();
+}

spec/helpers/spy_logger.h

@@ -1,14 +1,14 @@
-#ifndef HELPERS_SPY_DEBUGGER_H_
-#define HELPERS_SPY_DEBUGGER_H_
+#ifndef HELPERS_SPY_LOGGER_H_
+#define HELPERS_SPY_LOGGER_H_
 
 #include <string>
 #include <vector>
 #include "tree_sitter/runtime.h"
 
-class SpyDebugger {
+class SpyLogger {
  public:
   void clear();
-  TSDebugger debugger();
+  TSLogger logger();
   std::vector<std::string> messages;
 };
 

spec/helpers/stderr_logger.cc

@@ -1,22 +1,22 @@
 #include "tree_sitter/runtime.h"
 #include <stdio.h>
 
-static void log_debug(void *payload, TSDebugType type, const char *msg) {
+static void log(void *payload, TSLogType type, const char *msg) {
   bool include_lexing = (bool)payload;
   switch (type) {
-    case TSDebugTypeParse:
+    case TSLogTypeParse:
       fprintf(stderr, "* %s\n", msg);
       break;
-    case TSDebugTypeLex:
+    case TSLogTypeLex:
       if (include_lexing)
         fprintf(stderr, "  %s\n", msg);
       break;
   }
 }
 
-TSDebugger log_debugger_make(bool include_lexing) {
-  TSDebugger result;
+TSLogger stderr_logger_new(bool include_lexing) {
+  TSLogger result;
   result.payload = (void *)include_lexing;
-  result.debug_fn = log_debug;
+  result.log = log;
   return result;
 }

spec/helpers/stderr_logger.h

@@ -0,0 +1,8 @@
+#ifndef HELPERS_STDERR_LOGGER_H_
+#define HELPERS_STDERR_LOGGER_H_
+
+#include "tree_sitter/runtime.h"
+
+TSLogger stderr_logger_new(bool include_lexing);
+
+#endif  // HELPERS_STDERR_LOGGER_H_

spec/integration/corpus_specs.cc

@@ -3,7 +3,7 @@
 #include "helpers/load_language.h"
 #include "helpers/read_test_entries.h"
 #include "helpers/spy_input.h"
-#include "helpers/log_debugger.h"
+#include "helpers/stderr_logger.h"
 #include "helpers/point_helpers.h"
 #include "helpers/encoding_helpers.h"
 #include "helpers/record_alloc.h"
@@ -80,7 +80,7 @@ describe("The Corpus", []() {
         document = ts_document_new();
         ts_document_set_language(document, get_test_language(language_name));
 
-        // ts_document_set_debugger(document, log_debugger_make(true));
+        ts_document_set_logger(document, stderr_logger_new(true));
         // ts_document_print_debugging_graphs(document, true);
       });
 

spec/runtime/document_spec.cc

@@ -1,13 +1,11 @@
 #include "spec_helper.h"
 #include "runtime/alloc.h"
-#include "runtime/debugger.h"
 #include "helpers/record_alloc.h"
 #include "helpers/stream_methods.h"
 #include "helpers/tree_helpers.h"
-#include "helpers/spy_debugger.h"
+#include "helpers/spy_logger.h"
 #include "helpers/spy_input.h"
 #include "helpers/load_language.h"
-#include "helpers/log_debugger.h"
 
 START_TEST
 
@@ -146,51 +144,51 @@ describe("Document", [&]() {
     });
   });
 
-  describe("set_debugger(TSDebugger)", [&]() {
-    SpyDebugger *debugger;
+  describe("set_logger(TSDebugger)", [&]() {
+    SpyLogger *logger;
 
     before_each([&]() {
-      debugger = new SpyDebugger();
+      logger = new SpyLogger();
       ts_document_set_language(doc, get_test_language("json"));
       ts_document_set_input_string(doc, "[1, 2]");
     });
 
     after_each([&]() {
-      delete debugger;
+      delete logger;
     });
 
     it("calls the debugger with a message for each lex action", [&]() {
-      ts_document_set_debugger(doc, debugger->debugger());
+      ts_document_set_logger(doc, logger->logger());
       ts_document_parse(doc);
 
-      AssertThat(debugger->messages, Contains("lookahead char:'1'"));
-      AssertThat(debugger->messages, Contains("lookahead char:'['"));
+      AssertThat(logger->messages, Contains("lookahead char:'1'"));
+      AssertThat(logger->messages, Contains("lookahead char:'['"));
     });
 
     it("calls the debugger with a message for each parse action", [&]() {
-      ts_document_set_debugger(doc, debugger->debugger());
+      ts_document_set_logger(doc, logger->logger());
       ts_document_parse(doc);
 
-      AssertThat(debugger->messages, Contains("new_parse"));
-      AssertThat(debugger->messages, Contains("lookahead char:'['"));
-      AssertThat(debugger->messages, Contains("reduce sym:array, child_count:4"));
-      AssertThat(debugger->messages, Contains("accept"));
+      AssertThat(logger->messages, Contains("new_parse"));
+      AssertThat(logger->messages, Contains("lookahead char:'['"));
+      AssertThat(logger->messages, Contains("reduce sym:array, child_count:4"));
+      AssertThat(logger->messages, Contains("accept"));
     });
 
     it("allows the debugger to be retrieved later", [&]() {
-      ts_document_set_debugger(doc, debugger->debugger());
-      AssertThat(ts_document_debugger(doc).payload, Equals(debugger));
+      ts_document_set_logger(doc, logger->logger());
+      AssertThat(ts_document_logger(doc).payload, Equals(logger));
     });
 
     describe("disabling debugging", [&]() {
       before_each([&]() {
-        ts_document_set_debugger(doc, debugger->debugger());
-        ts_document_set_debugger(doc, ts_debugger_null());
+        ts_document_set_logger(doc, logger->logger());
+        ts_document_set_logger(doc, {NULL, NULL});
       });
 
       it("does not call the debugger any more", [&]() {
         ts_document_parse(doc);
-        AssertThat(debugger->messages, IsEmpty());
+        AssertThat(logger->messages, IsEmpty());
       });
     });
   });

spec/runtime/parser_spec.cc

@@ -3,7 +3,6 @@
 #include "helpers/record_alloc.h"
 #include "helpers/spy_input.h"
 #include "helpers/load_language.h"
-#include "helpers/log_debugger.h"
 #include "helpers/record_alloc.h"
 
 START_TEST

src/runtime/debugger.h

@@ -1,19 +0,0 @@
-#ifndef RUNTIME_DEBUGGER_H_
-#define RUNTIME_DEBUGGER_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "tree_sitter/runtime.h"
-
-static inline TSDebugger ts_debugger_null() {
-  TSDebugger debugger = { 0, 0 };
-  return debugger;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // RUNTIME_DEBUGGER_H_

src/runtime/document.c

@@ -44,12 +44,12 @@ void ts_document_set_language(TSDocument *self, const TSLanguage *language) {
   }
 }
 
-TSDebugger ts_document_debugger(const TSDocument *self) {
-  return self->parser.lexer.debugger;
+TSLogger ts_document_logger(const TSDocument *self) {
+  return self->parser.lexer.logger;
 }
 
-void ts_document_set_debugger(TSDocument *self, TSDebugger debugger) {
-  self->parser.lexer.debugger = debugger;
+void ts_document_set_logger(TSDocument *self, TSLogger logger) {
+  self->parser.lexer.logger = logger;
 }
 
 void ts_document_print_debugging_graphs(TSDocument *self, bool should_print) {

src/runtime/lexer.c

@@ -3,14 +3,13 @@
 #include "tree_sitter/parser.h"
 #include "runtime/tree.h"
 #include "runtime/length.h"
-#include "runtime/debugger.h"
 #include "runtime/utf16.h"
 #include "utf8proc.h"
 
 #define LOG(...)                                                     \
-  if (self->debugger.debug_fn) {                                     \
+  if (self->logger.log) {                                     \
     snprintf(self->debug_buffer, TS_DEBUG_BUFFER_SIZE, __VA_ARGS__); \
-    self->debugger.debug_fn(self->debugger.payload, TSDebugTypeLex,  \
+    self->logger.log(self->logger.payload, TSLogTypeLex,  \
                             self->debug_buffer);                     \
   }
 
@@ -86,7 +85,7 @@ void ts_lexer_init(TSLexer *self) {
     .advance = ts_lexer__advance,
     .chunk = NULL,
     .chunk_start = 0,
-    .debugger = ts_debugger_null(),
+    .logger = {},
   };
   ts_lexer_reset(self, ts_length_zero());
 }

src/runtime/parser.c

@@ -15,10 +15,10 @@
 #include "runtime/error_costs.h"
 
 #define LOG(...)                                                               \
-  if (self->lexer.debugger.debug_fn) {                                         \
+  if (self->lexer.logger.log) {                                         \
     snprintf(self->lexer.debug_buffer, TS_DEBUG_BUFFER_SIZE, __VA_ARGS__);     \
-    self->lexer.debugger.debug_fn(self->lexer.debugger.payload,                \
-                                  TSDebugTypeParse, self->lexer.debug_buffer); \
+    self->lexer.logger.log(self->lexer.logger.payload,                \
+                                  TSLogTypeParse, self->lexer.debug_buffer); \
   }                                                                            \
   if (self->print_debugging_graphs) {                                          \
     fprintf(stderr, "graph {\nlabel=\"");                                      \