ruby_tree_sitter 0.20.6.3-x86_64-linux

data/ext/tree_sitter/logger.c

@@ -0,0 +1,212 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cLogger;
+
+// This type is layed out in the DATA_* style.
+// data: the TSLogger object
+// payload: what will be used in TSLogger.log()
+//          therefore: data.payload = payload
+// format: optional formatting string. Passed to "printf" if it exists
+typedef struct {
+  TSLogger data;
+  VALUE payload;
+  VALUE format;
+} logger_t;
+
+static const char *logger_log_type_str(TSLogType log_type) {
+  switch (log_type) {
+  case TSLogTypeParse:
+    return "Parse:";
+  case TSLogTypeLex:
+    return "Lex  :";
+  default:
+    return "?????:";
+  }
+}
+
+static void logger_log_printf(void *ptr, TSLogType log_type,
+                              const char *message) {
+  logger_t *logger = (logger_t *)ptr;
+  VALUE type = safe_str(logger_log_type_str(log_type));
+  VALUE msg = safe_str(message);
+  rb_funcall(logger->payload, rb_intern("printf"), 3, logger->format, type,
+             msg);
+}
+
+static void logger_log_puts(void *ptr, TSLogType log_type,
+                            const char *message) {
+  logger_t *logger = (logger_t *)ptr;
+  const char *format =
+      NIL_P(logger->format) ? "%s %s" : StringValueCStr(logger->format);
+  VALUE str = rb_sprintf(format, logger_log_type_str(log_type), message);
+  rb_funcall(logger->payload, rb_intern("puts"), 1, str);
+}
+
+static void logger_log_write(void *ptr, TSLogType log_type,
+                             const char *message) {
+  logger_t *logger = (logger_t *)ptr;
+  const char *format =
+      NIL_P(logger->format) ? "%s %s\n" : StringValueCStr(logger->format);
+  VALUE str = rb_sprintf(format, logger_log_type_str(log_type), message);
+  rb_funcall(logger->payload, rb_intern("write"), 1, str);
+}
+
+static void logger_payload_set(logger_t *logger, VALUE value) {
+  logger->payload = value;
+  logger->data.payload = (void *)logger;
+
+  if (!NIL_P(logger->format) && !NIL_P(logger->payload)) {
+    if (rb_respond_to(logger->payload, rb_intern("printf"))) {
+      logger->data.log = logger_log_printf;
+    } else if (rb_respond_to(logger->payload, rb_intern("puts"))) {
+      logger->data.log = &logger_log_puts;
+    } else {
+      logger->data.log = &logger_log_write;
+    }
+  } else if (!NIL_P(logger->payload)) {
+    logger->data.log = &logger_log_write;
+  }
+}
+
+static void logger_free(void *ptr) { xfree(ptr); }
+
+static size_t logger_memsize(const void *ptr) {
+  logger_t *type = (logger_t *)ptr;
+  return sizeof(type);
+}
+
+static void logger_mark(void *ptr) {
+  logger_t *logger = (logger_t *)ptr;
+  rb_gc_mark_movable(logger->payload);
+  // we don't want format to move because its reference will be
+  // consumed by the parser.
+  //
+  // No funny things please.
+  rb_gc_mark(logger->format);
+}
+
+static void logger_compact(void *ptr) {
+  logger_t *logger = (logger_t *)ptr;
+  logger->payload = rb_gc_location(logger->payload);
+}
+
+const rb_data_type_t logger_data_type = {
+    .wrap_struct_name = "logger",
+    .function =
+        {
+            .dmark = logger_mark,
+            .dfree = logger_free,
+            .dsize = logger_memsize,
+            .dcompact = logger_compact,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+DATA_UNWRAP(logger)
+
+static VALUE logger_allocate(VALUE klass) {
+  logger_t *logger;
+  return TypedData_Make_Struct(klass, logger_t, &logger_data_type, logger);
+}
+
+VALUE new_logger(const TSLogger *ptr) {
+  if (ptr != NULL) {
+    VALUE res = logger_allocate(cLogger);
+    logger_t *logger = unwrap(res);
+
+    logger->data.payload = logger;
+
+    VALUE payload = Qnil;
+    VALUE format = Qnil;
+    if (ptr->payload != NULL) {
+      logger_t *old_logger = (logger_t *)ptr->payload;
+      payload = old_logger->payload;
+      format = old_logger->format;
+    }
+    logger_payload_set(logger, payload);
+    logger->format = format;
+
+    return res;
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE new_logger_by_val(TSLogger val) { return new_logger(&val); }
+
+TSLogger value_to_logger(VALUE self) { return SELF; }
+
+static void logger_initialize_stderr(logger_t *logger) {
+  VALUE stderr = rb_gv_get("$stderr");
+  if (!NIL_P(stderr)) {
+    logger_payload_set(logger, stderr);
+  } else {
+    logger_payload_set(logger, Qnil);
+  }
+}
+
+// For now, we only take:
+// argv[0] = stream
+// argv[1] = format : String
+//
+// We need to add support for argv[1] : lambda/block
+//
+// case argv[1]
+// in lambda => lambda
+// in String => puts || printf || write
+// else      => write
+// end
+//
+static VALUE logger_initialize(int argc, VALUE *argv, VALUE self) {
+  logger_t *logger = unwrap(self);
+
+  VALUE payload;
+  VALUE format;
+  rb_scan_args(argc, argv, "02", &payload, &format);
+
+  logger->format = format;
+
+  if (argc == 0) {
+    logger_initialize_stderr(logger);
+  } else {
+    logger_payload_set(logger, payload);
+  }
+
+  return self;
+}
+
+static VALUE logger_inspect(VALUE self) {
+  logger_t *logger = unwrap(self);
+  return rb_sprintf("{payload=%+" PRIsVALUE ", format=%+" PRIsVALUE "}",
+                    logger->payload, logger->format);
+}
+
+DATA_FAST_FORWARD_FNV(logger, write, payload)
+DATA_FAST_FORWARD_FNV(logger, puts, payload)
+DATA_FAST_FORWARD_FNV(logger, printf, payload)
+
+DEFINE_ACCESSOR(logger, format)
+DEFINE_GETTER(logger, payload)
+
+static VALUE logger_set_payload(VALUE self, VALUE payload) {
+  logger_payload_set(unwrap(self), payload);
+  return Qnil;
+}
+
+void init_logger(void) {
+  cLogger = rb_define_class_under(mTreeSitter, "Logger", rb_cObject);
+
+  rb_define_alloc_func(cLogger, logger_allocate);
+
+  /* Class methods */
+  rb_define_method(cLogger, "initialize", logger_initialize, -1);
+  DECLARE_ACCESSOR(cLogger, logger, format)
+  DECLARE_ACCESSOR(cLogger, logger, payload)
+  rb_define_method(cLogger, "write", logger_write, -1);
+  rb_define_method(cLogger, "puts", logger_puts, -1);
+  rb_define_method(cLogger, "printf", logger_printf, -1);
+  rb_define_method(cLogger, "inspect", logger_inspect, 0);
+  rb_define_method(cLogger, "to_s", logger_inspect, 0);
+}

data/ext/tree_sitter/macros.h

@@ -0,0 +1,163 @@
+#ifndef _RB_TREE_SITTER_MACROS_H
+#define _RB_TREE_SITTER_MACROS_H
+
+#define DECLARE_GETTER(klass, type, field)                                     \
+  rb_define_method(klass, #field, type##_get_##field, 0);
+
+#define DECLARE_SETTER(klass, type, field)                                     \
+  rb_define_method(klass, #field "=", type##_set_##field, 1);
+
+#define DECLARE_ACCESSOR(klass, type, field)                                   \
+  DECLARE_GETTER(klass, type, field)                                           \
+  DECLARE_SETTER(klass, type, field)
+
+// Plain DEFINE_GETTER/DEFINE_SETTER/etc are for TypedData structs, reaching
+// their top-level fields, and are of type VALUE
+//
+// DATA_* are for TypeData structs, raching their data field
+// which can be of an arbitraty tuype.
+
+#define DEFINE_GETTER(type, field)                                             \
+  static VALUE type##_get_##field(VALUE self) { return (unwrap(self))->field; }
+
+#define DEFINE_SETTER(type, field)                                             \
+  static VALUE type##_set_##field(VALUE self, VALUE val) {                     \
+    unwrap(self)->field = val;                                                 \
+    return Qnil;                                                               \
+  }
+
+#define DEFINE_ACCESSOR(type, field)                                           \
+  DEFINE_GETTER(type, field)                                                   \
+  DEFINE_SETTER(type, field)
+
+#define DATA_WRAP(base, type)                                                  \
+  DATA_TYPE(TS##base, type)                                                    \
+  DATA_FREE(type)                                                              \
+  DATA_MEMSIZE(type)                                                           \
+  DATA_DECLARE_DATA_TYPE(type)                                                 \
+  DATA_ALLOCATE(type)                                                          \
+  DATA_UNWRAP(type)                                                            \
+  DATA_NEW(c##base, TS##base, type)                                            \
+  DATA_FROM_VALUE(TS##base, type)
+
+#define DATA_PTR_WRAP(base, type)                                              \
+  DATA_TYPE(TS##base *, type)                                                  \
+  DATA_FREE_PTR(type)                                                          \
+  DATA_MEMSIZE(type)                                                           \
+  DATA_DECLARE_DATA_TYPE(type)                                                 \
+  DATA_ALLOCATE(type)                                                          \
+  DATA_UNWRAP(type)                                                            \
+  DATA_PTR_NEW(c##base, TS##base, type)                                        \
+  DATA_FROM_VALUE(TS##base *, type)
+
+#define DATA_TYPE(klass, type)                                                 \
+  typedef struct {                                                             \
+    klass data;                                                                \
+  } type##_t;
+
+#define DATA_FREE(type)                                                        \
+  static void type##_free(void *ptr) { xfree(ptr); }
+
+#define DATA_FREE_PTR(type)                                                    \
+  static void type##_free(void *ptr) {                                         \
+    type##_t *type = (type##_t *)ptr;                                          \
+    if (type->data != NULL) {                                                  \
+      ts_##type##_delete(type->data);                                          \
+    }                                                                          \
+    xfree(ptr);                                                                \
+  }
+
+#define DATA_MEMSIZE(type)                                                     \
+  static size_t type##_memsize(const void *ptr) {                              \
+    type##_t *type = (type##_t *)ptr;                                          \
+    return sizeof(type);                                                       \
+  }
+
+#define DATA_DECLARE_DATA_TYPE(type)                                           \
+  const rb_data_type_t type##_data_type = {                                    \
+      .wrap_struct_name = #type "",                                            \
+      .function =                                                              \
+          {                                                                    \
+              .dmark = NULL,                                                   \
+              .dfree = type##_free,                                            \
+              .dsize = type##_memsize,                                         \
+              .dcompact = NULL,                                                \
+          },                                                                   \
+      .flags = RUBY_TYPED_FREE_IMMEDIATELY,                                    \
+  };
+
+#define DATA_ALLOCATE(type)                                                    \
+  static VALUE type##_allocate(VALUE klass) {                                  \
+    type##_t *type;                                                            \
+    return TypedData_Make_Struct(klass, type##_t, &type##_data_type, type);    \
+  }
+
+#define DATA_UNWRAP(type)                                                      \
+  static type##_t *unwrap(VALUE self) {                                        \
+    type##_t *type;                                                            \
+    TypedData_Get_Struct(self, type##_t, &type##_data_type, type);             \
+    return type;                                                               \
+  }
+
+#define SELF unwrap(self)->data
+
+#define DATA_NEW(klass, struct, type)                                          \
+  VALUE new_##type(const struct *ptr) {                                        \
+    if (ptr == NULL) {                                                         \
+      return Qnil;                                                             \
+    }                                                                          \
+    VALUE res = type##_allocate(klass);                                        \
+    type##_t *type = unwrap(res);                                              \
+    type->data = *ptr;                                                         \
+    return res;                                                                \
+  }                                                                            \
+  VALUE new_##type##_by_val(struct ptr) {                                      \
+    VALUE res = type##_allocate(klass);                                        \
+    type##_t *type = unwrap(res);                                              \
+    type->data = ptr;                                                          \
+    return res;                                                                \
+  }
+
+#define DATA_FROM_VALUE(struct, type)                                          \
+  struct value_to_##type(VALUE self) {                                         \
+    return (unwrap(self))->data;                                               \
+  }
+
+#define DATA_PTR_NEW(klass, struct, type)                                      \
+  VALUE new_##type(struct *ptr) {                                              \
+    if (ptr == NULL) {                                                         \
+      return Qnil;                                                             \
+    }                                                                          \
+    VALUE res = type##_allocate(klass);                                        \
+    type##_t *type = unwrap(res);                                              \
+    type->data = ptr;                                                          \
+    return res;                                                                \
+  }
+
+#define DATA_DEFINE_GETTER(type, field, cast)                                  \
+  static VALUE type##_get_##field(VALUE self) {                                \
+    return cast((unwrap(self))->data.field);                                   \
+  }
+
+#define DATA_DEFINE_SETTER(type, field, cast)                                  \
+  static VALUE type##_set_##field(VALUE self, VALUE val) {                     \
+    type##_t *type = unwrap(self);                                             \
+    type->data.field = cast(val);                                              \
+    return Qnil;                                                               \
+  }
+
+#define DATA_DEFINE_ACCESSOR(type, field, cast_get, cast_set)                  \
+  DATA_DEFINE_GETTER(type, field, cast_get)                                    \
+  DATA_DEFINE_SETTER(type, field, cast_set)
+
+#define DATA_FAST_FORWARD_FNV(type, fn, field)                                 \
+  static VALUE type##_##fn(int argc, VALUE *argv, VALUE self) {                \
+    type##_t *type = unwrap(self);                                             \
+    if (!NIL_P(type->field)) {                                                 \
+      return rb_funcallv(type->field, rb_intern(#fn ""), argc, argv);          \
+    } else {                                                                   \
+      return Qnil;                                                             \
+    }                                                                          \
+  }
+
+#endif

data/ext/tree_sitter/node.c

@@ -0,0 +1,310 @@
+#include "tree_sitter.h"
+#include "tree_sitter/api.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cNode;
+
+DATA_TYPE(TSNode, node)
+
+static void node_free(void *ptr) {
+  node_t *type = (node_t *)ptr;
+  tree_rc_free(type->data.tree);
+  xfree(ptr);
+}
+
+DATA_MEMSIZE(node)
+DATA_DECLARE_DATA_TYPE(node)
+DATA_ALLOCATE(node)
+DATA_UNWRAP(node)
+
+VALUE new_node(const TSNode *ptr) {
+  if (ptr == NULL) {
+    return Qnil;
+  }
+  VALUE res = node_allocate(cNode);
+  node_t *type = unwrap(res);
+  type->data = *ptr;
+  tree_rc_new(type->data.tree);
+  return res;
+}
+VALUE new_node_by_val(TSNode ptr) {
+  VALUE res = node_allocate(cNode);
+  node_t *type = unwrap(res);
+  type->data = ptr;
+  tree_rc_new(type->data.tree);
+  return res;
+}
+
+DATA_FROM_VALUE(TSNode, node)
+
+static VALUE node_type(VALUE self) { return safe_symbol(ts_node_type(SELF)); }
+
+static VALUE node_symbol(VALUE self) { return UINT2NUM(ts_node_symbol(SELF)); }
+
+static VALUE node_start_byte(VALUE self) {
+  return UINT2NUM(ts_node_start_byte(SELF));
+}
+
+static VALUE node_start_point(VALUE self) {
+  return new_point_by_val(ts_node_start_point(SELF));
+}
+
+static VALUE node_end_byte(VALUE self) {
+  return UINT2NUM(ts_node_end_byte(SELF));
+}
+
+static VALUE node_end_point(VALUE self) {
+  return new_point_by_val(ts_node_end_point(SELF));
+}
+
+static VALUE node_string(VALUE self) {
+  char *str = ts_node_string(SELF);
+  VALUE res = safe_str(str);
+  if (str) {
+    free(str);
+  }
+  return res;
+}
+
+static VALUE node_is_null(VALUE self) {
+  return ts_node_is_null(SELF) ? Qtrue : Qfalse;
+}
+
+static VALUE node_is_named(VALUE self) {
+  return ts_node_is_named(SELF) ? Qtrue : Qfalse;
+}
+
+static VALUE node_is_missing(VALUE self) {
+  return ts_node_is_missing(SELF) ? Qtrue : Qfalse;
+}
+
+static VALUE node_is_extra(VALUE self) {
+  return ts_node_is_extra(SELF) ? Qtrue : Qfalse;
+}
+
+static VALUE node_has_changes(VALUE self) {
+  return ts_node_has_changes(SELF) ? Qtrue : Qfalse;
+}
+
+static VALUE node_has_error(VALUE self) {
+  return ts_node_has_error(SELF) ? Qtrue : Qfalse;
+}
+
+static VALUE node_parent(VALUE self) {
+  return new_node_by_val(ts_node_parent(SELF));
+}
+
+static VALUE node_child(VALUE self, VALUE idx) {
+  TSNode node = SELF;
+  uint32_t index = NUM2UINT(idx);
+  uint32_t range = ts_node_child_count(node);
+
+  if (index < range) {
+    return new_node_by_val(ts_node_child(node, index));
+  } else {
+    rb_raise(rb_eIndexError, "Index %d is out of range (len = %d)", index,
+             range);
+  }
+}
+
+static VALUE node_field_name_for_child(VALUE self, VALUE idx) {
+  TSNode node = SELF;
+  uint32_t index = NUM2UINT(idx);
+  uint32_t range = ts_node_child_count(node);
+
+  if (index < range) {
+    return safe_str(ts_node_field_name_for_child(node, index));
+  } else {
+    rb_raise(rb_eIndexError, "Index %d is out of range (len = %d)", index,
+             range);
+  }
+}
+
+static VALUE node_child_count(VALUE self) {
+  TSNode node = SELF;
+  const char *type = ts_node_type(node);
+  if (strcmp(type, "end") == 0) {
+    return UINT2NUM(0);
+  } else {
+    return UINT2NUM(ts_node_child_count(SELF));
+  }
+}
+
+static VALUE node_named_child(VALUE self, VALUE idx) {
+  TSNode node = SELF;
+  uint32_t index = NUM2UINT(idx);
+  uint32_t range = ts_node_named_child_count(node);
+
+  if (index < range) {
+    return new_node_by_val(ts_node_named_child(node, index));
+  } else {
+    rb_raise(rb_eIndexError, "Index %d is out of range (len = %d)", index,
+             range);
+  }
+}
+
+static VALUE node_named_child_count(VALUE self) {
+  return UINT2NUM(ts_node_named_child_count(SELF));
+}
+
+static VALUE node_child_by_field_name(VALUE self, VALUE field_name) {
+  const char *name = StringValuePtr(field_name);
+  uint32_t length = (uint32_t)RSTRING_LEN(field_name);
+  return new_node_by_val(ts_node_child_by_field_name(SELF, name, length));
+}
+
+static VALUE node_child_by_field_id(VALUE self, VALUE field_id) {
+  return new_node_by_val(ts_node_child_by_field_id(SELF, NUM2UINT(field_id)));
+}
+
+static VALUE node_next_sibling(VALUE self) {
+  return new_node_by_val(ts_node_next_sibling(SELF));
+}
+
+static VALUE node_prev_sibling(VALUE self) {
+  return new_node_by_val(ts_node_prev_sibling(SELF));
+}
+
+static VALUE node_next_named_sibling(VALUE self) {
+  return new_node_by_val(ts_node_next_named_sibling(SELF));
+}
+
+static VALUE node_prev_named_sibling(VALUE self) {
+  return new_node_by_val(ts_node_prev_named_sibling(SELF));
+}
+
+static VALUE node_first_child_for_byte(VALUE self, VALUE byte) {
+  return new_node_by_val(ts_node_first_child_for_byte(SELF, NUM2UINT(byte)));
+}
+
+static VALUE node_first_named_child_for_byte(VALUE self, VALUE byte) {
+  return new_node_by_val(
+      ts_node_first_named_child_for_byte(SELF, NUM2UINT(byte)));
+}
+
+static VALUE node_descendant_for_byte_range(VALUE self, VALUE from, VALUE to) {
+  uint32_t from_b = NUM2UINT(from);
+  uint32_t to_b = NUM2UINT(to);
+
+  if (from_b > to_b) {
+    rb_raise(rb_eIndexError, "From > To: %d > %d", from_b, to_b);
+  } else {
+    return new_node_by_val(
+        ts_node_descendant_for_byte_range(SELF, from_b, to_b));
+  }
+}
+
+static VALUE node_descendant_for_point_range(VALUE self, VALUE from, VALUE to) {
+  TSNode node = SELF;
+  TSPoint start = ts_node_start_point(node);
+  TSPoint end = ts_node_end_point(node);
+  TSPoint f = value_to_point(from);
+  TSPoint t = value_to_point(to);
+
+  if ((f.row < start.row) || (t.row > end.row) ||
+      (f.row == start.row && (f.column < start.column)) ||
+      (t.row == end.row && (t.column > end.column))) {
+    rb_raise(rb_eIndexError,
+             "Invalid point range: [%+" PRIsVALUE ", %+" PRIsVALUE
+             "] is not in [%+" PRIsVALUE ", %+" PRIsVALUE "].",
+             from, to, new_point(&start), new_point(&end));
+  } else {
+    return new_node_by_val(ts_node_descendant_for_point_range(node, f, t));
+  }
+}
+
+static VALUE node_named_descendant_for_byte_range(VALUE self, VALUE from,
+                                                  VALUE to) {
+  uint32_t from_b = NUM2UINT(from);
+  uint32_t to_b = NUM2UINT(to);
+
+  if (from_b > to_b) {
+    rb_raise(rb_eIndexError, "From > To: %d > %d", from_b, to_b);
+  } else {
+    return new_node_by_val(
+        ts_node_named_descendant_for_byte_range(SELF, from_b, to_b));
+  }
+}
+
+static VALUE node_named_descendant_for_point_range(VALUE self, VALUE from,
+                                                   VALUE to) {
+  TSNode node = SELF;
+  TSPoint start = ts_node_start_point(node);
+  TSPoint end = ts_node_end_point(node);
+  TSPoint f = value_to_point(from);
+  TSPoint t = value_to_point(to);
+
+  if ((f.row < start.row) || (t.row > end.row) ||
+      (f.row == start.row && (f.column < start.column)) ||
+      (t.row == end.row && (t.column > end.column))) {
+    rb_raise(rb_eIndexError,
+             "Invalid point range: [%+" PRIsVALUE ", %+" PRIsVALUE
+             "] is not in [%+" PRIsVALUE ", %+" PRIsVALUE "].",
+             from, to, new_point(&start), new_point(&end));
+  } else {
+    return new_node_by_val(
+        ts_node_named_descendant_for_point_range(node, f, t));
+  }
+}
+
+static VALUE node_edit(VALUE self, VALUE input_edit) {
+  TSNode node = SELF;
+  TSInputEdit edit = value_to_input_edit(input_edit);
+  ts_node_edit(&node, &edit);
+
+  return Qnil;
+}
+
+static VALUE node_eq(VALUE self, VALUE other) {
+  return ts_node_eq(SELF, unwrap(other)->data) ? Qtrue : Qfalse;
+}
+
+void init_node(void) {
+  cNode = rb_define_class_under(mTreeSitter, "Node", rb_cObject);
+
+  rb_undef_alloc_func(cNode);
+
+  /* Class methods */
+  rb_define_method(cNode, "type", node_type, 0);
+  rb_define_method(cNode, "symbol", node_symbol, 0);
+  rb_define_method(cNode, "start_byte", node_start_byte, 0);
+  rb_define_method(cNode, "start_point", node_start_point, 0);
+  rb_define_method(cNode, "end_byte", node_end_byte, 0);
+  rb_define_method(cNode, "end_point", node_end_point, 0);
+  rb_define_method(cNode, "null?", node_is_null, 0);
+  rb_define_method(cNode, "named?", node_is_named, 0);
+  rb_define_method(cNode, "missing?", node_is_missing, 0);
+  rb_define_method(cNode, "extra?", node_is_extra, 0);
+  rb_define_method(cNode, "changed?", node_has_changes, 0);
+  rb_define_method(cNode, "error?", node_has_error, 0);
+  rb_define_method(cNode, "parent", node_parent, 0);
+  rb_define_method(cNode, "child", node_child, 1);
+  rb_define_method(cNode, "field_name_for_child", node_field_name_for_child, 1);
+  rb_define_method(cNode, "child_count", node_child_count, 0);
+  rb_define_method(cNode, "named_child", node_named_child, 1);
+  rb_define_method(cNode, "named_child_count", node_named_child_count, 0);
+  rb_define_method(cNode, "child_by_field_name", node_child_by_field_name, 1);
+  rb_define_method(cNode, "child_by_field_id", node_child_by_field_id, 1);
+  rb_define_method(cNode, "next_sibling", node_next_sibling, 0);
+  rb_define_method(cNode, "prev_sibling", node_prev_sibling, 0);
+  rb_define_method(cNode, "next_named_sibling", node_next_named_sibling, 0);
+  rb_define_method(cNode, "prev_named_sibling", node_prev_named_sibling, 0);
+  rb_define_method(cNode, "first_child_for_byte", node_first_child_for_byte, 1);
+  rb_define_method(cNode, "first_named_child_for_byte",
+                   node_first_named_child_for_byte, 1);
+  rb_define_method(cNode, "descendant_for_byte_range",
+                   node_descendant_for_byte_range, 2);
+  rb_define_method(cNode, "descendant_for_point_range",
+                   node_descendant_for_point_range, 2);
+  rb_define_method(cNode, "named_descendant_for_byte_range",
+                   node_named_descendant_for_byte_range, 2);
+  rb_define_method(cNode, "named_descendant_for_point_range",
+                   node_named_descendant_for_point_range, 2);
+  rb_define_method(cNode, "eq?", node_eq, 1);
+  rb_define_method(cNode, "edit", node_edit, 1);
+  rb_define_method(cNode, "to_s", node_string, 0);
+  rb_define_method(cNode, "to_str", node_string, 0);
+  rb_define_method(cNode, "inspect", node_string, 0);
+  rb_define_method(cNode, "==", node_eq, 1);
+}