rbs 1.6.2 → 1.7.0.beta.1

data/ext/rbs/extension/lexer.h

@@ -0,0 +1,145 @@
+#ifndef RBS__LEXER_H
+#define RBS__LEXER_H
+
+enum TokenType {
+  NullType,         /* (Nothing) */
+  pEOF,             /* EOF */
+  ErrorToken,       /* Error */
+
+  pLPAREN,          /* ( */
+  pRPAREN,          /* ) */
+  pCOLON,           /* : */
+  pCOLON2,          /* :: */
+  pLBRACKET,        /* [ */
+  pRBRACKET,        /* ] */
+  pLBRACE,          /* { */
+  pRBRACE,          /* } */
+  pHAT,             /* ^ */
+  pARROW,           /* -> */
+  pFATARROW,        /* => */
+  pCOMMA,           /* , */
+  pBAR,             /* | */
+  pAMP,             /* & */
+  pSTAR,            /* * */
+  pSTAR2,           /* ** */
+  pDOT,             /* . */
+  pDOT3,            /* ... */
+  pBANG,            /* ! */
+  pQUESTION,        /* ? */
+  pLT,              /* < */
+  pEQ,              /* = */
+
+  kBOOL,            /* bool */
+  kBOT,             /* bot */
+  kCLASS,           /* class */
+  kFALSE,           /* false */
+  kINSTANCE,        /* instance */
+  kINTERFACE,       /* interface */
+  kNIL,             /* nil */
+  kSELF,            /* self */
+  kSINGLETON,       /* singleton */
+  kTOP,             /* top */
+  kTRUE,            /* true */
+  kVOID,            /* void */
+  kTYPE,            /* type */
+  kUNCHECKED,       /* unchecked */
+  kIN,              /* in */
+  kOUT,             /* out */
+  kEND,             /* end */
+  kDEF,             /* def */
+  kINCLUDE,         /* include */
+  kEXTEND,          /* extend */
+  kPREPEND,         /* prepend */
+  kALIAS,           /* alias */
+  kMODULE,          /* module */
+  kATTRREADER,      /* attr_reader */
+  kATTRWRITER,      /* attr_writer */
+  kATTRACCESSOR,    /* attr_accessor */
+  kPUBLIC,          /* public */
+  kPRIVATE,         /* private */
+  kUNTYPED,         /* untyped */
+
+  tLIDENT,          /* Identifiers starting with lower case */
+  tUIDENT,          /* Identifiers starting with upper case */
+  tULIDENT,         /* Identifiers starting with `_` followed by upper case */
+  tULLIDENT,        /* Identifiers starting with `_` followed by lower case */
+  tGIDENT,          /* Identifiers starting with `$` */
+  tAIDENT,          /* Identifiers starting with `@` */
+  tA2IDENT,         /* Identifiers starting with `@@` */
+  tBANGIDENT,       /* Identifiers ending with `!` */
+  tEQIDENT,         /* Identifiers ending with `=` */
+  tQIDENT,          /* Quoted identifier */
+  tOPERATOR,         /* Operator identifier */
+
+  tCOMMENT,         /* Comment */
+  tLINECOMMENT,     /* Comment of all line */
+
+  tDQSTRING,        /* Double quoted string */
+  tSQSTRING,        /* Single quoted string */
+  tINTEGER,         /* Integer */
+  tSYMBOL,          /* Symbol */
+  tDQSYMBOL,        /* Double quoted symbol */
+  tSQSYMBOL,        /* Single quoted symbol */
+  tANNOTATION,      /* Annotation */
+};
+
+/**
+ * The `byte_pos` (or `char_pos`) is the primary data.
+ * The rest are cache.
+ *
+ * They can be computed from `byte_pos` (or `char_pos`), but it needs full scan from the beginning of the string (depending on the encoding).
+ * */
+typedef struct {
+  int byte_pos;
+  int char_pos;
+  int line;
+  int column;
+} position;
+
+typedef struct {
+  position start;
+  position end;
+} range;
+
+typedef struct {
+  enum TokenType type;
+  range range;
+} token;
+
+/**
+ * The lexer state is the curren token.
+ *
+ * ```
+ * ... "a string token"
+ *    ^                      start position
+ *          ^                current position
+ *     ~~~~~~                Token => "a str
+ * ```
+ * */
+typedef struct {
+  VALUE string;
+  position current;               /* The current position */
+  position start;                 /* The start position of the current token */
+  bool first_token_of_line;       /* This flag is used for tLINECOMMENT */
+} lexstate;
+
+extern token NullToken;
+extern position NullPosition;
+extern range NULL_RANGE;
+
+token rbsparser_next_token(lexstate *state);
+
+char *peek_token(lexstate *state, token tok);
+int token_chars(token tok);
+int token_bytes(token tok);
+
+#define null_position_p(pos) (pos.byte_pos == -1)
+#define null_range_p(range) (range.start.byte_pos == -1)
+#define nonnull_pos_or(pos1, pos2) (null_position_p(pos1) ? pos2 : pos1)
+#define RANGE_BYTES(range) (range.end.byte_pos - range.start.byte_pos)
+
+const char *token_type_str(enum TokenType type);
+
+void print_token(token tok);
+
+#endif

data/ext/rbs/extension/location.c

@@ -0,0 +1,295 @@
+#include "rbs_extension.h"
+
+VALUE RBS_Location;
+
+rbs_loc_list *rbs_loc_list_add(rbs_loc_list *list, const ID name, const range r) {
+  rbs_loc_list *new = malloc(sizeof(rbs_loc_list));
+  new->next = list;
+  new->name = name;
+  new->rg = r;
+  return new;
+}
+
+rbs_loc_list *rbs_loc_list_dup(rbs_loc_list *list) {
+  if (list) {
+    return rbs_loc_list_add(rbs_loc_list_dup(list->next), list->name, list->rg);
+  } else {
+    return NULL;
+  }
+}
+
+void rbs_loc_list_free(rbs_loc_list *list) {
+  while (list) {
+    rbs_loc_list *next = list->next;
+    free(list);
+    list = next;
+  }
+}
+
+bool rbs_loc_list_find(const rbs_loc_list *list, ID name, range *rg) {
+  while (list) {
+    if (list->name == name) {
+      *rg = list->rg;
+      return true;
+    }
+
+    list = list->next;
+  }
+
+  return false;
+}
+
+size_t rbs_loc_list_size(const rbs_loc_list *list) {
+  size_t size = 0;
+
+  while (list) {
+    size += 1;
+    list = list->next;
+  }
+
+  return size;
+}
+
+position rbs_loc_position(int char_pos) {
+  position pos = { 0, char_pos, -1, -1 };
+  return pos;
+}
+
+position rbs_loc_position3(int char_pos, int line, int column) {
+  position pos = { 0, char_pos, line, column };
+  return pos;
+}
+
+void rbs_loc_add_required_child(rbs_loc *loc, ID name, range r) {
+  loc->requireds = rbs_loc_list_add(loc->requireds, name, r);
+}
+
+void rbs_loc_add_optional_child(rbs_loc *loc, ID name, range r) {
+  loc->optionals = rbs_loc_list_add(loc->optionals, name, r);
+}
+
+void rbs_loc_init(rbs_loc *loc, VALUE buffer, range rg) {
+  loc->buffer = buffer;
+  loc->rg = rg;
+  loc->optionals = NULL;
+  loc->requireds = NULL;
+}
+
+void rbs_loc_free(rbs_loc *loc) {
+  rbs_loc_list_free(loc->optionals);
+  rbs_loc_list_free(loc->requireds);
+  ruby_xfree(loc);
+}
+
+static void rbs_loc_mark(void *ptr)
+{
+  rbs_loc *loc = ptr;
+  rb_gc_mark(loc->buffer);
+}
+
+static size_t rbs_loc_memsize(const void *ptr) {
+  const rbs_loc *loc = ptr;
+  return sizeof(*loc) + (rbs_loc_list_size(loc->optionals) + rbs_loc_list_size(loc->requireds)) * sizeof(rbs_loc_list);
+}
+
+static rb_data_type_t location_type = {
+  "RBS::Location",
+  {rbs_loc_mark, (RUBY_DATA_FUNC)rbs_loc_free, rbs_loc_memsize},
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE location_s_allocate(VALUE klass) {
+  rbs_loc *loc;
+  VALUE obj = TypedData_Make_Struct(klass, rbs_loc, &location_type, loc);
+
+  rbs_loc_init(loc, Qnil, NULL_RANGE);
+
+  return obj;
+}
+
+rbs_loc *rbs_check_location(VALUE obj) {
+  return rb_check_typeddata(obj, &location_type);
+}
+
+static VALUE location_initialize(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos) {
+  rbs_loc *loc = rbs_check_location(self);
+
+  position start = rbs_loc_position(FIX2INT(start_pos));
+  position end = rbs_loc_position(FIX2INT(end_pos));
+
+  loc->buffer = buffer;
+  loc->rg.start = start;
+  loc->rg.end = end;
+
+  return Qnil;
+}
+
+static VALUE location_initialize_copy(VALUE self, VALUE other) {
+  rbs_loc *self_loc = rbs_check_location(self);
+  rbs_loc *other_loc = rbs_check_location(other);
+
+  self_loc->buffer = other_loc->buffer;
+  self_loc->rg = other_loc->rg;
+  self_loc->requireds = rbs_loc_list_dup(other_loc->requireds);
+  self_loc->optionals = rbs_loc_list_dup(other_loc->optionals);
+
+  return Qnil;
+}
+
+static VALUE location_buffer(VALUE self) {
+  rbs_loc *loc = rbs_check_location(self);
+  return loc->buffer;
+}
+
+static VALUE location_start_pos(VALUE self) {
+  rbs_loc *loc = rbs_check_location(self);
+  return INT2FIX(loc->rg.start.char_pos);
+}
+
+static VALUE location_end_pos(VALUE self) {
+  rbs_loc *loc = rbs_check_location(self);
+  return INT2FIX(loc->rg.end.char_pos);
+}
+
+static VALUE location_start_loc(VALUE self) {
+  rbs_loc *loc = rbs_check_location(self);
+
+  if (loc->rg.start.line >= 0) {
+    VALUE pair = rb_ary_new_capa(2);
+    rb_ary_push(pair, INT2FIX(loc->rg.start.line));
+    rb_ary_push(pair, INT2FIX(loc->rg.start.column));
+    return pair;
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE location_end_loc(VALUE self) {
+  rbs_loc *loc = rbs_check_location(self);
+
+  if (loc->rg.end.line >= 0) {
+    VALUE pair = rb_ary_new_capa(2);
+    rb_ary_push(pair, INT2FIX(loc->rg.end.line));
+    rb_ary_push(pair, INT2FIX(loc->rg.end.column));
+    return pair;
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE location_add_required_child(VALUE self, VALUE name, VALUE start, VALUE end) {
+  rbs_loc *loc = rbs_check_location(self);
+
+  range rg;
+  rg.start = rbs_loc_position(FIX2INT(start));
+  rg.end = rbs_loc_position(FIX2INT(end));
+
+  rbs_loc_add_required_child(loc, SYM2ID(name), rg);
+
+  return Qnil;
+}
+
+static VALUE location_add_optional_child(VALUE self, VALUE name, VALUE start, VALUE end) {
+  rbs_loc *loc = rbs_check_location(self);
+
+  range rg;
+  rg.start = rbs_loc_position(FIX2INT(start));
+  rg.end = rbs_loc_position(FIX2INT(end));
+
+  rbs_loc_add_optional_child(loc, SYM2ID(name), rg);
+
+  return Qnil;
+}
+
+static VALUE location_add_optional_no_child(VALUE self, VALUE name) {
+  rbs_loc *loc = rbs_check_location(self);
+
+  rbs_loc_add_optional_child(loc, SYM2ID(name), NULL_RANGE);
+
+  return Qnil;
+}
+
+VALUE rbs_new_location(VALUE buffer, range rg) {
+  rbs_loc *loc;
+  VALUE obj = TypedData_Make_Struct(RBS_Location, rbs_loc, &location_type, loc);
+
+  rbs_loc_init(loc, buffer, rg);
+
+  return obj;
+}
+
+static VALUE location_aref(VALUE self, VALUE name) {
+  rbs_loc *loc = rbs_check_location(self);
+
+  range result;
+  ID id = SYM2ID(name);
+
+  if (rbs_loc_list_find(loc->requireds, id, &result)) {
+    return rbs_new_location(loc->buffer, result);
+  }
+
+  if (rbs_loc_list_find(loc->optionals, id, &result)) {
+    if (null_range_p(result)) {
+      return Qnil;
+    } else {
+      return rbs_new_location(loc->buffer, result);
+    }
+  }
+
+  VALUE string = rb_funcall(name, rb_intern("to_s"), 0);
+  rb_raise(rb_eRuntimeError, "Unknown child name given: %s", RSTRING_PTR(string));
+}
+
+static VALUE location_optional_keys(VALUE self) {
+  VALUE keys = rb_ary_new();
+
+  rbs_loc *loc = rbs_check_location(self);
+  rbs_loc_list *list = loc->optionals;
+
+  while (list) {
+    rb_ary_push(keys, ID2SYM(list->name));
+    list = list->next;
+  }
+
+  return keys;
+}
+
+static VALUE location_required_keys(VALUE self) {
+  VALUE keys = rb_ary_new();
+
+  rbs_loc *loc = rbs_check_location(self);
+  rbs_loc_list *list = loc->requireds;
+
+  while (list) {
+    rb_ary_push(keys, ID2SYM(list->name));
+    list = list->next;
+  }
+
+  return keys;
+}
+
+VALUE rbs_location_pp(VALUE buffer, const position *start_pos, const position *end_pos) {
+  range rg = { *start_pos, *end_pos };
+  rg.start = *start_pos;
+  rg.end = *end_pos;
+
+  return rbs_new_location(buffer, rg);
+}
+
+void rbs__init_location() {
+  RBS_Location = rb_define_class_under(RBS, "Location", rb_cObject);
+  rb_define_alloc_func(RBS_Location, location_s_allocate);
+  rb_define_private_method(RBS_Location, "initialize", location_initialize, 3);
+  rb_define_private_method(RBS_Location, "initialize_copy", location_initialize_copy, 1);
+  rb_define_method(RBS_Location, "buffer", location_buffer, 0);
+  rb_define_method(RBS_Location, "start_pos", location_start_pos, 0);
+  rb_define_method(RBS_Location, "end_pos", location_end_pos, 0);
+  rb_define_private_method(RBS_Location, "_start_loc", location_start_loc, 0);
+  rb_define_private_method(RBS_Location, "_end_loc", location_end_loc, 0);
+  rb_define_method(RBS_Location, "_add_required_child", location_add_required_child, 3);
+  rb_define_method(RBS_Location, "_add_optional_child", location_add_optional_child, 3);
+  rb_define_method(RBS_Location, "_add_optional_no_child", location_add_optional_no_child, 1);
+  rb_define_method(RBS_Location, "_optional_keys", location_optional_keys, 0);
+  rb_define_method(RBS_Location, "_required_keys", location_required_keys, 0);
+  rb_define_method(RBS_Location, "[]", location_aref, 1);
+}

data/ext/rbs/extension/location.h

@@ -0,0 +1,59 @@
+#ifndef RBS_LOCATION_H
+#define RBS_LOCATION_H
+
+#include "ruby.h"
+#include "lexer.h"
+
+/**
+ * RBS::Location class
+ * */
+extern VALUE RBS_Location;
+
+typedef struct rbs_loc_list {
+  ID name;
+  range rg;
+  struct rbs_loc_list *next;
+} rbs_loc_list;
+
+typedef struct {
+  VALUE buffer;
+  range rg;
+  rbs_loc_list *requireds;
+  rbs_loc_list *optionals;
+} rbs_loc;
+
+/**
+ * Returns new RBS::Location object, with given buffer and range.
+ * */
+VALUE rbs_new_location(VALUE buffer, range rg);
+
+/**
+ * Return rbs_loc assiciated with the RBS::Location object.
+ * */
+rbs_loc *rbs_check_location(VALUE location);
+
+/**
+ * Add a required child range with given name.
+ * */
+void rbs_loc_add_required_child(rbs_loc *loc, ID name, range r);
+
+/**
+ * Add an optional child range with given name.
+ * */
+void rbs_loc_add_optional_child(rbs_loc *loc, ID name, range r);
+
+/**
+ * Returns RBS::Location object with start/end positions.
+ *
+ * @param start_pos
+ * @param end_pos
+ * @return New RSS::Location object.
+ * */
+VALUE rbs_location_pp(VALUE buffer, const position *start_pos, const position *end_pos);
+
+/**
+ * Define RBS::Location class.
+ * */
+void rbs__init_location();
+
+#endif