Add Document getter methods for input, language

include/tree_sitter/runtime.h

@@ -14,10 +14,9 @@ typedef struct {
 } TSLength;
 
 typedef struct {
-  void *data;
-  const char *(*read_fn)(void *data, size_t *bytes_read);
-  int (*seek_fn)(void *data, TSLength position);
-  void (*release_fn)(void *data);
+  void *payload;
+  const char *(*read_fn)(void *payload, size_t *bytes_read);
+  int (*seek_fn)(void *payload, TSLength position);
 } TSInput;
 
 typedef enum {
@@ -26,9 +25,8 @@ typedef enum {
 } TSDebugType;
 
 typedef struct {
-  void *data;
-  void (*debug_fn)(void *data, TSDebugType, const char *);
-  void (*release_fn)(void *data);
+  void *payload;
+  void (*debug_fn)(void *payload, TSDebugType, const char *);
 } TSDebugger;
 
 typedef struct {
@@ -67,11 +65,13 @@ TSNode ts_node_named_descendent_for_range(TSNode, size_t, size_t);
 
 TSDocument *ts_document_make();
 void ts_document_free(TSDocument *);
+const TSLanguage * ts_document_language(TSDocument *);
 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 *);
 void ts_document_edit(TSDocument *, TSInputEdit);
-TSDebugger ts_document_get_debugger(const TSDocument *);
+TSDebugger ts_document_debugger(const TSDocument *);
 void ts_document_set_debugger(TSDocument *, TSDebugger);
 TSNode ts_document_root_node(const TSDocument *);
 

spec/runtime/document_spec.cc

@@ -1,6 +1,7 @@
 #include "runtime/debugger.h"
-#include "runtime/helpers/spy_debugger.h"
 #include "runtime/runtime_spec_helper.h"
+#include "runtime/helpers/spy_debugger.h"
+#include "runtime/helpers/spy_input.h"
 
 extern "C" const TSLanguage * ts_language_json();
 
@@ -38,6 +39,13 @@ describe("Document", [&]() {
         AssertThat(ts_document_root_node(doc).data, Equals<void *>(nullptr));
       });
     });
+
+    it("allows the input to be retrieved later", [&]() {
+      auto spy_input = new SpyInput("12345", 3);
+      ts_document_set_input(doc, spy_input->input());
+      AssertThat(ts_document_input(doc).payload, Equals<void *>(spy_input));
+      delete spy_input;
+    });
   });
 
   describe("set_language(TSLanguage)", [&]() {
@@ -61,6 +69,11 @@ describe("Document", [&]() {
           "(object (string) (array (number) (number)))"));
       });
     });
+
+    it("allows the language to be retrieved later", [&]() {
+      ts_document_set_language(doc, ts_language_json());
+      AssertThat(ts_document_language(doc), Equals(ts_language_json()));
+    });
   });
 
   describe("set_debugger(TSDebugger)", [&]() {
@@ -90,7 +103,7 @@ describe("Document", [&]() {
     });
 
     it("allows the debugger to be retrieved later", [&]() {
-      AssertThat(ts_document_get_debugger(doc).payload, Equals(debugger));
+      AssertThat(ts_document_debugger(doc).payload, Equals(debugger));
     });
 
     describe("disabling debugging", [&]() {

src/runtime/document.c

@@ -29,19 +29,27 @@ static void ts_document__reparse(TSDocument *document, TSInputEdit *edit) {
   }
 }
 
+const TSLanguage * ts_document_language(TSDocument *document) {
+  return document->parser.language;
+}
+
 void ts_document_set_language(TSDocument *document, const TSLanguage *language) {
   document->parser.language = language;
   ts_document__reparse(document, NULL);
 }
 
-TSDebugger ts_document_get_debugger(const TSDocument *document) {
-  return ts_parser_get_debugger(&document->parser);
+TSDebugger ts_document_debugger(const TSDocument *document) {
+  return ts_parser_debugger(&document->parser);
 }
 
 void ts_document_set_debugger(TSDocument *document, TSDebugger debugger) {
   ts_parser_set_debugger(&document->parser, debugger);
 }
 
+TSInput ts_document_input(TSDocument *document) {
+  return document->input;
+}
+
 void ts_document_set_input(TSDocument *document, TSInput input) {
   document->input = input;
   ts_document__reparse(document, NULL);

src/runtime/parser.c

@@ -428,7 +428,7 @@ void ts_parser_destroy(TSParser *parser) {
     ts_tree_release(parser->lookahead);
 }
 
-TSDebugger ts_parser_get_debugger(const TSParser *parser) {
+TSDebugger ts_parser_debugger(const TSParser *parser) {
   return parser->lexer.debugger;
 }
 

src/runtime/parser.h

@@ -19,7 +19,7 @@ typedef struct {
 
 TSParser ts_parser_make();
 void ts_parser_destroy(TSParser *);
-TSDebugger ts_parser_get_debugger(const TSParser *);
+TSDebugger ts_parser_debugger(const TSParser *);
 void ts_parser_set_debugger(TSParser *, TSDebugger);
 TSTree *ts_parser_parse(TSParser *, TSInput, TSInputEdit *);