rbs 3.5.2 → 3.6.0.dev.1

data/ext/rbs_extension/parser.c

@@ -52,6 +52,14 @@ typedef struct {
   VALUE rest_keywords;
 } method_params;
 
+static VALUE EMPTY_ARRAY;
+
+static void inline melt_array(VALUE *array) {
+  if (*array == EMPTY_ARRAY) {
+    *array = rb_ary_new();
+  }
+}
+
 static bool rbs_is_untyped_params(method_params *params) {
   return NIL_P(params->required_positionals);
 }
@@ -137,7 +145,7 @@ void parser_advance_no_gap(parserstate *state) {
 */
 VALUE parse_type_name(parserstate *state, TypeNameKind kind, range *rg) {
   VALUE absolute = Qfalse;
-  VALUE path = rb_ary_new();
+  VALUE path = EMPTY_ARRAY;
   VALUE namespace;
 
   if (rg) {
@@ -155,6 +163,7 @@ VALUE parse_type_name(parserstate *state, TypeNameKind kind, range *rg) {
     && state->current_token.range.end.byte_pos == state->next_token.range.start.byte_pos
     && state->next_token.range.end.byte_pos == state->next_token2.range.start.byte_pos
   ) {
+    melt_array(&path);
     rb_ary_push(path, ID2SYM(INTERN_TOKEN(state, state->current_token)));
 
     parser_advance(state);
@@ -211,9 +220,10 @@ VALUE parse_type_name(parserstate *state, TypeNameKind kind, range *rg) {
   type_list ::= {} type `,` ... <`,`> eol
               | {} type `,` ... `,` <type> eol
 */
-static VALUE parse_type_list(parserstate *state, enum TokenType eol, VALUE types) {
+static void parse_type_list(parserstate *state, enum TokenType eol, VALUE *types) {
   while (true) {
-    rb_ary_push(types, parse_type(state));
+    melt_array(types);
+    rb_ary_push(*types, parse_type(state));
 
     if (state->next_token.type == pCOMMA) {
       parser_advance(state);
@@ -233,8 +243,6 @@ static VALUE parse_type_list(parserstate *state, enum TokenType eol, VALUE types
       }
     }
   }
-
-  return types;
 }
 
 static bool is_keyword_token(enum TokenType type) {
@@ -329,11 +337,22 @@ static VALUE parse_keyword_key(parserstate *state) {
 /*
   keyword ::= {} keyword `:` <function_param>
 */
-static void parse_keyword(parserstate *state, VALUE keywords) {
+static void parse_keyword(parserstate *state, VALUE keywords, VALUE memo) {
   VALUE key;
   VALUE param;
 
   key = parse_keyword_key(state);
+
+  if (!NIL_P(rb_hash_aref(memo, key))) {
+    raise_syntax_error(
+      state,
+      state->current_token,
+      "duplicated keyword argument"
+    );
+  } else {
+    rb_hash_aset(memo, key, Qtrue);
+  }
+
   parser_advance_assert(state, pCOLON);
   param = parse_function_param(state);
 
@@ -403,6 +422,8 @@ static void parse_params(parserstate *state, method_params *params) {
     return;
   }
 
+  VALUE memo = rb_hash_new();
+
   while (true) {
     VALUE param;
 
@@ -422,6 +443,7 @@ static void parse_params(parserstate *state, method_params *params) {
         }
 
         param = parse_function_param(state);
+        melt_array(&params->required_positionals);
         rb_ary_push(params->required_positionals, param);
 
         break;
@@ -441,12 +463,13 @@ PARSE_OPTIONAL_PARAMS:
         parser_advance(state);
 
         if (is_keyword(state)) {
-          parse_keyword(state, params->optional_keywords);
+          parse_keyword(state, params->optional_keywords, memo);
           parser_advance_if(state, pCOMMA);
           goto PARSE_KEYWORDS;
         }
 
         param = parse_function_param(state);
+        melt_array(&params->optional_positionals);
         rb_ary_push(params->optional_positionals, param);
 
         break;
@@ -490,6 +513,7 @@ PARSE_TRAILING_PARAMS:
         }
 
         param = parse_function_param(state);
+        melt_array(&params->trailing_positionals);
         rb_ary_push(params->trailing_positionals, param);
 
         break;
@@ -506,7 +530,7 @@ PARSE_KEYWORDS:
     case pQUESTION:
       parser_advance(state);
       if (is_keyword(state)) {
-        parse_keyword(state, params->optional_keywords);
+        parse_keyword(state, params->optional_keywords, memo);
       } else {
         raise_syntax_error(
           state,
@@ -529,7 +553,7 @@ PARSE_KEYWORDS:
     case tBANGIDENT:
     KEYWORD_CASES
       if (is_keyword(state)) {
-        parse_keyword(state, params->required_keywords);
+        parse_keyword(state, params->required_keywords, memo);
       } else {
         raise_syntax_error(
           state,
@@ -580,10 +604,10 @@ static VALUE parse_optional(parserstate *state) {
 }
 
 static void initialize_method_params(method_params *params){
-  params->required_positionals = rb_ary_new();
-  params->optional_positionals = rb_ary_new();
+  params->required_positionals = EMPTY_ARRAY;
+  params->optional_positionals = EMPTY_ARRAY;
   params->rest_positionals = Qnil;
-  params->trailing_positionals = rb_ary_new();
+  params->trailing_positionals = EMPTY_ARRAY;
   params->required_keywords = rb_hash_new();
   params->optional_keywords = rb_hash_new();
   params->rest_keywords = Qnil;
@@ -713,6 +737,16 @@ static VALUE parse_proc_type(parserstate *state) {
   return rbs_proc(function, block, loc, proc_self);
 }
 
+static void check_key_duplication(parserstate *state, VALUE fields, VALUE key) {
+  if (!NIL_P(rb_hash_aref(fields, key))) {
+    raise_syntax_error(
+      state,
+      state->current_token,
+      "duplicated record key"
+    );
+  }
+}
+
 /**
  * ... `{` ... `}` ...
  *        >   >
@@ -744,6 +778,7 @@ VALUE parse_record_attributes(parserstate *state) {
     if (is_keyword(state)) {
       // { foo: type } syntax
       key = parse_keyword_key(state);
+      check_key_duplication(state, fields, key);
       parser_advance_assert(state, pCOLON);
     } else {
       // { key => type } syntax
@@ -765,6 +800,7 @@ VALUE parse_record_attributes(parserstate *state) {
           "unexpected record key token"
         );
       }
+      check_key_duplication(state, fields, key);
       parser_advance_assert(state, pFATARROW);
     }
     type = parse_type(state);
@@ -838,7 +874,7 @@ static VALUE parse_instance_type(parserstate *state, bool parse_alias) {
     }
 
     VALUE typename = parse_type_name(state, expected_kind, &name_range);
-    VALUE types = rb_ary_new();
+    VALUE types = EMPTY_ARRAY;
 
     TypeNameKind kind;
     if (state->current_token.type == tUIDENT) {
@@ -854,7 +890,7 @@ static VALUE parse_instance_type(parserstate *state, bool parse_alias) {
     if (state->next_token.type == pLBRACKET) {
       parser_advance(state);
       args_range.start = state->current_token.range.start;
-      parse_type_list(state, pRBRACKET, types);
+      parse_type_list(state, pRBRACKET, &types);
       parser_advance_assert(state, pRBRACKET);
       args_range.end = state->current_token.range.end;
     } else {
@@ -993,9 +1029,9 @@ static VALUE parse_simple(parserstate *state) {
   case pLBRACKET: {
     range rg;
     rg.start = state->current_token.range.start;
-    VALUE types = rb_ary_new();
+    VALUE types = EMPTY_ARRAY;
     if (state->next_token.type != pRBRACKET) {
-      parse_type_list(state, pRBRACKET, types);
+      parse_type_list(state, pRBRACKET, &types);
     }
     parser_advance_assert(state, pRBRACKET);
     rg.end = state->current_token.range.end;
@@ -1003,7 +1039,7 @@ static VALUE parse_simple(parserstate *state) {
     return rbs_tuple(types, rbs_new_location(state->buffer, rg));
   }
   case pAREF_OPR: {
-    return rbs_tuple(rb_ary_new(), rbs_new_location(state->buffer, state->current_token.range));
+    return rbs_tuple(EMPTY_ARRAY, rbs_new_location(state->buffer, state->current_token.range));
   }
   case pLBRACE: {
     position start = state->current_token.range.start;
@@ -1083,12 +1119,14 @@ VALUE parse_type(parserstate *state) {
   type_params ::= {} `[` type_param `,` ... <`]`>
                 | {<>}
 
-  type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT    (module_type_params == true)
+  type_param ::= kUNCHECKED? (kIN|kOUT|) tUIDENT upper_bound? default_type?   (module_type_params == true)
 
-  type_param ::= tUIDENT                            (module_type_params == false)
+  type_param ::= tUIDENT upper_bound? default_type?                           (module_type_params == false)
 */
 VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params) {
-  VALUE params = rb_ary_new();
+  VALUE params = EMPTY_ARRAY;
+
+  bool required_param_allowed = true;
 
   if (state->next_token.type == pLBRACKET) {
     parser_advance(state);
@@ -1100,12 +1138,14 @@ VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params)
       bool unchecked = false;
       VALUE variance = ID2SYM(rb_intern("invariant"));
       VALUE upper_bound = Qnil;
+      VALUE default_type = Qnil;
 
       range param_range = NULL_RANGE;
       range name_range;
       range variance_range = NULL_RANGE;
       range unchecked_range = NULL_RANGE;
       range upper_bound_range = NULL_RANGE;
+      range default_type_range = NULL_RANGE;
 
       param_range.start = state->next_token.range.start;
 
@@ -1143,13 +1183,28 @@ VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params)
 
       if (state->next_token.type == pLT) {
         parser_advance(state);
+        upper_bound_range.start = state->current_token.range.start;
+        upper_bound = parse_type(state);
+        upper_bound_range.end = state->current_token.range.end;
+      }
 
-        if (state->next_token.type == kSINGLETON) {
+      if (module_type_params) {
+        if (state->next_token.type == pEQ) {
           parser_advance(state);
-          upper_bound = parse_singleton_type(state);
+
+          default_type_range.start = state->current_token.range.start;
+          default_type = parse_type(state);
+          default_type_range.start = state->current_token.range.end;
+
+          required_param_allowed = false;
         } else {
-          parser_advance(state);
-          upper_bound = parse_instance_type(state, false);
+          if (!required_param_allowed) {
+            raise_syntax_error(
+              state,
+              state->current_token,
+              "required type parameter is not allowed after optional type parameter"
+            );
+          }
         }
       }
 
@@ -1162,8 +1217,10 @@ VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params)
       rbs_loc_add_optional_child(loc, rb_intern("variance"), variance_range);
       rbs_loc_add_optional_child(loc, rb_intern("unchecked"), unchecked_range);
       rbs_loc_add_optional_child(loc, rb_intern("upper_bound"), upper_bound_range);
+      rbs_loc_add_optional_child(loc, rb_intern("default"), default_type_range);
 
-      VALUE param = rbs_ast_type_param(name, variance, unchecked, upper_bound, location);
+      VALUE param = rbs_ast_type_param(name, variance, unchecked, upper_bound, default_type, location);
+      melt_array(&params);
       rb_ary_push(params, param);
 
       if (state->next_token.type == pCOMMA) {
@@ -1403,7 +1460,7 @@ VALUE parse_annotation(parserstate *state) {
   annotations ::= {} annotation ... <annotation>
                 | {<>}
 */
-void parse_annotations(parserstate *state, VALUE annotations, position *annot_pos) {
+void parse_annotations(parserstate *state, VALUE *annotations, position *annot_pos) {
   *annot_pos = NullPosition;
 
   while (true) {
@@ -1414,7 +1471,8 @@ void parse_annotations(parserstate *state, VALUE annotations, position *annot_po
         *annot_pos = state->current_token.range.start;
       }
 
-      rb_ary_push(annotations, parse_annotation(state));
+      melt_array(annotations);
+      rb_ary_push(*annotations, parse_annotation(state));
     } else {
       break;
     }
@@ -1598,11 +1656,11 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
 
   bool loop = true;
   while (loop) {
-    VALUE annotations = rb_ary_new();
+    VALUE annotations = EMPTY_ARRAY;
     position overload_annot_pos = NullPosition;
 
     if (state->next_token.type == tANNOTATION) {
-      parse_annotations(state, annotations, &overload_annot_pos);
+      parse_annotations(state, &annotations, &overload_annot_pos);
     }
 
     switch (state->next_token.type) {
@@ -1693,7 +1751,7 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
  *
  * @param kind
  * */
-void class_instance_name(parserstate *state, TypeNameKind kind, VALUE *name, VALUE args, range *name_range, range *args_range) {
+void class_instance_name(parserstate *state, TypeNameKind kind, VALUE *name, VALUE *args, range *name_range, range *args_range) {
   parser_advance(state);
 
   *name = parse_type_name(state, kind, name_range);
@@ -1760,11 +1818,11 @@ VALUE parse_mixin_member(parserstate *state, bool from_interface, position comme
   parser_push_typevar_table(state, reset_typevar_scope);
 
   VALUE name;
-  VALUE args = rb_ary_new();
+  VALUE args = EMPTY_ARRAY;
   class_instance_name(
     state,
     from_interface ? INTERFACE_NAME : (INTERFACE_NAME | CLASS_NAME),
-    &name, args, &name_range, &args_range
+    &name, &args, &name_range, &args_range
   );
 
   parser_pop_typevar_table(state);
@@ -2116,13 +2174,13 @@ VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE ann
                      | alias_member   (instance only)
 */
 VALUE parse_interface_members(parserstate *state) {
-  VALUE members = rb_ary_new();
+  VALUE members = EMPTY_ARRAY;
 
   while (state->next_token.type != kEND) {
-    VALUE annotations = rb_ary_new();
+    VALUE annotations = EMPTY_ARRAY;
     position annot_pos = NullPosition;
 
-    parse_annotations(state, annotations, &annot_pos);
+    parse_annotations(state, &annotations, &annot_pos);
 
     parser_advance(state);
 
@@ -2150,6 +2208,7 @@ VALUE parse_interface_members(parserstate *state) {
       );
     }
 
+    melt_array(&members);
     rb_ary_push(members, member);
   }
 
@@ -2206,7 +2265,7 @@ VALUE parse_interface_decl(parserstate *state, position comment_pos, VALUE annot
   module_self_type ::= <module_name>
                      | module_name `[` type_list <`]`>
 */
-void parse_module_self_types(parserstate *state, VALUE array) {
+void parse_module_self_types(parserstate *state, VALUE *array) {
   while (true) {
     range self_range;
     range name_range;
@@ -2219,11 +2278,11 @@ void parse_module_self_types(parserstate *state, VALUE array) {
     VALUE module_name = parse_type_name(state, CLASS_NAME | INTERFACE_NAME, &name_range);
     self_range.end = name_range.end;
 
-    VALUE args = rb_ary_new();
+    VALUE args = EMPTY_ARRAY;
     if (state->next_token.type == pLBRACKET) {
       parser_advance(state);
       args_range.start = state->current_token.range.start;
-      parse_type_list(state, pRBRACKET, args);
+      parse_type_list(state, pRBRACKET, &args);
       parser_advance(state);
       self_range.end = args_range.end = state->current_token.range.end;
     }
@@ -2235,7 +2294,8 @@ void parse_module_self_types(parserstate *state, VALUE array) {
     rbs_loc_add_optional_child(loc, rb_intern("args"), args_range);
 
     VALUE self_type = rbs_ast_decl_module_self(module_name, args, location);
-    rb_ary_push(array, self_type);
+    melt_array(array);
+    rb_ary_push(*array, self_type);
 
     if (state->next_token.type == pCOMMA) {
       parser_advance(state);
@@ -2259,14 +2319,14 @@ VALUE parse_nested_decl(parserstate *state, const char *nested_in, position anno
                   | `private`
 */
 VALUE parse_module_members(parserstate *state) {
-  VALUE members = rb_ary_new();
+  VALUE members = EMPTY_ARRAY;
 
   while (state->next_token.type != kEND) {
     VALUE member;
-    VALUE annotations = rb_ary_new();
+    VALUE annotations = EMPTY_ARRAY;
     position annot_pos = NullPosition;
 
-    parse_annotations(state, annotations, &annot_pos);
+    parse_annotations(state, &annotations, &annot_pos);
 
     parser_advance(state);
 
@@ -2324,6 +2384,7 @@ VALUE parse_module_members(parserstate *state) {
       break;
     }
 
+    melt_array(&members);
     rb_ary_push(members, member);
   }
 
@@ -2346,13 +2407,13 @@ VALUE parse_module_decl0(parserstate *state, range keyword_range, VALUE module_n
   decl_range.start = keyword_range.start;
 
   VALUE type_params = parse_type_params(state, &type_params_range, true);
-  VALUE self_types = rb_ary_new();
+  VALUE self_types = EMPTY_ARRAY;
 
   if (state->next_token.type == pCOLON) {
     parser_advance(state);
     colon_range = state->current_token.range;
     self_types_range.start = state->next_token.range.start;
-    parse_module_self_types(state, self_types);
+    parse_module_self_types(state, &self_types);
     self_types_range.end = state->current_token.range.end;
   } else {
     colon_range = NULL_RANGE;
@@ -2447,8 +2508,8 @@ VALUE parse_class_decl_super(parserstate *state, range *lt_range) {
     *lt_range = state->current_token.range;
     super_range.start = state->next_token.range.start;
 
-    args = rb_ary_new();
-    class_instance_name(state, CLASS_NAME, &name, args, &name_range, &args_range);
+    args = EMPTY_ARRAY;
+    class_instance_name(state, CLASS_NAME, &name, &args, &name_range, &args_range);
 
     super_range.end = state->current_token.range.end;
 
@@ -2601,10 +2662,10 @@ VALUE parse_nested_decl(parserstate *state, const char *nested_in, position anno
 }
 
 VALUE parse_decl(parserstate *state) {
-  VALUE annotations = rb_ary_new();
+  VALUE annotations = EMPTY_ARRAY;
   position annot_pos = NullPosition;
 
-  parse_annotations(state, annotations, &annot_pos);
+  parse_annotations(state, &annotations, &annot_pos);
 
   parser_advance(state);
   switch (state->current_token.type) {
@@ -2645,10 +2706,11 @@ VALUE parse_namespace(parserstate *state, range *rg) {
     parser_advance(state);
   }
 
-  VALUE path = rb_ary_new();
+  VALUE path = EMPTY_ARRAY;
 
   while (true) {
     if (state->next_token.type == tUIDENT && state->next_token2.type == pCOLON2) {
+      melt_array(&path);
       rb_ary_push(path, ID2SYM(INTERN_TOKEN(state, state->next_token)));
       if (null_position_p(rg->start)) {
         rg->start = state->next_token.range.start;
@@ -2788,14 +2850,16 @@ VALUE parse_use_directive(parserstate *state) {
 }
 
 VALUE parse_signature(parserstate *state) {
-  VALUE dirs = rb_ary_new();
-  VALUE decls = rb_ary_new();
+  VALUE dirs = EMPTY_ARRAY;
+  VALUE decls = EMPTY_ARRAY;
 
   while (state->next_token.type == kUSE) {
+    melt_array(&dirs);
     rb_ary_push(dirs, parse_use_directive(state));
   }
 
   while (state->next_token.type != pEOF) {
+    melt_array(&decls);
     rb_ary_push(decls, parse_decl(state));
   }
 
@@ -2836,7 +2900,10 @@ parse_type_try(VALUE a) {
 static VALUE
 rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof)
 {
-  parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
+  VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+  StringValue(string);
+  lexstate *lexer = alloc_lexer(string, FIX2INT(start_pos), FIX2INT(end_pos));
+  parserstate *parser = alloc_parser(buffer, lexer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
   struct parse_type_arg arg = {
     parser,
     require_eof
@@ -2864,7 +2931,10 @@ parse_method_type_try(VALUE a) {
 static VALUE
 rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof)
 {
-  parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
+  VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+  StringValue(string);
+  lexstate *lexer = alloc_lexer(string, FIX2INT(start_pos), FIX2INT(end_pos));
+  parserstate *parser = alloc_parser(buffer, lexer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
   struct parse_type_arg arg = {
     parser,
     require_eof
@@ -2881,13 +2951,18 @@ parse_signature_try(VALUE a) {
 static VALUE
 rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE end_pos)
 {
-  parserstate *parser = alloc_parser(buffer, 0, FIX2INT(end_pos), Qnil);
+  VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+  StringValue(string);
+  lexstate *lexer = alloc_lexer(string, 0, FIX2INT(end_pos));
+  parserstate *parser = alloc_parser(buffer, lexer, 0, FIX2INT(end_pos), Qnil);
   return rb_ensure(parse_signature_try, (VALUE)parser, ensure_free_parser, (VALUE)parser);
 }
 
 static VALUE
 rbsparser_lex(VALUE self, VALUE buffer, VALUE end_pos) {
-  lexstate *lexer = alloc_lexer(buffer, 0, FIX2INT(end_pos));
+  VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+  StringValue(string);
+  lexstate *lexer = alloc_lexer(string, 0, FIX2INT(end_pos));
   VALUE results = rb_ary_new();
 
   token token = NullToken;
@@ -2906,6 +2981,11 @@ rbsparser_lex(VALUE self, VALUE buffer, VALUE end_pos) {
 
 void rbs__init_parser(void) {
   RBS_Parser = rb_define_class_under(RBS, "Parser", rb_cObject);
+  rb_gc_register_mark_object(RBS_Parser);
+  VALUE empty_array = rb_obj_freeze(rb_ary_new());
+  rb_gc_register_mark_object(empty_array);
+  EMPTY_ARRAY = empty_array;
+
   rb_define_singleton_method(RBS_Parser, "_parse_type", rbsparser_parse_type, 5);
   rb_define_singleton_method(RBS_Parser, "_parse_method_type", rbsparser_parse_method_type, 5);
   rb_define_singleton_method(RBS_Parser, "_parse_signature", rbsparser_parse_signature, 2);

data/ext/rbs_extension/parserstate.c

@@ -274,11 +274,7 @@ VALUE comment_to_ruby(comment *com, VALUE buffer) {
   );
 }
 
-lexstate *alloc_lexer(VALUE buffer, int start_pos, int end_pos) {
-  VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
-
-  StringValue(string);
-
+lexstate *alloc_lexer(VALUE string, int start_pos, int end_pos) {
   if (start_pos < 0 || end_pos < 0) {
     rb_raise(rb_eArgError, "negative position range: %d...%d", start_pos, end_pos);
   }
@@ -295,8 +291,7 @@ lexstate *alloc_lexer(VALUE buffer, int start_pos, int end_pos) {
   return lexer;
 }
 
-parserstate *alloc_parser(VALUE buffer, int start_pos, int end_pos, VALUE variables) {
-  lexstate *lexer = alloc_lexer(buffer, start_pos, end_pos);
+parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_pos, VALUE variables) {
   parserstate *parser = calloc(1, sizeof(parserstate));
   parser->lexstate = lexer;
   parser->buffer = buffer;

data/ext/rbs_extension/parserstate.h

@@ -97,20 +97,21 @@ bool parser_typevar_member(parserstate *state, ID id);
  * Allocate new lexstate object.
  *
  * ```
- * alloc_lexer(buffer, 0, 31)    // New lexstate with buffer
+ * VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+ * alloc_lexer(string, 0, 31)    // New lexstate with buffer content
  * ```
  * */
-lexstate *alloc_lexer(VALUE buffer, int start_pos, int end_pos);
+lexstate *alloc_lexer(VALUE string, int start_pos, int end_pos);
 
 /**
  * Allocate new parserstate object.
  *
  * ```
- * alloc_parser(buffer, 0, 1, variables)    // New parserstate with variables
- * alloc_parser(buffer, 3, 5, Qnil)         // New parserstate without variables
+ * alloc_parser(buffer, lexer, 0, 1, variables)    // New parserstate with variables
+ * alloc_parser(buffer, lexer, 3, 5, Qnil)         // New parserstate without variables
  * ```
  * */
-parserstate *alloc_parser(VALUE buffer, int start_pos, int end_pos, VALUE variables);
+parserstate *alloc_parser(VALUE buffer, lexstate *lexer, int start_pos, int end_pos, VALUE variables);
 void free_parser(parserstate *parser);
 /**
  * Advance one token.

data/ext/rbs_extension/ruby_objs.c

@@ -307,11 +307,12 @@ VALUE rbs_ast_annotation(VALUE string, VALUE location) {
   );
 }
 
-VALUE rbs_ast_type_param(VALUE name, VALUE variance, bool unchecked, VALUE upper_bound, VALUE location) {
+VALUE rbs_ast_type_param(VALUE name, VALUE variance, bool unchecked, VALUE upper_bound, VALUE default_type, VALUE location) {
   VALUE args = rb_hash_new();
   rb_hash_aset(args, ID2SYM(rb_intern("name")), name);
   rb_hash_aset(args, ID2SYM(rb_intern("variance")), variance);
   rb_hash_aset(args, ID2SYM(rb_intern("upper_bound")), upper_bound);
+  rb_hash_aset(args, ID2SYM(rb_intern("default_type")), default_type);
   rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
 
   VALUE type_param = CLASS_NEW_INSTANCE(RBS_AST_TypeParam, 1, &args);

data/ext/rbs_extension/ruby_objs.h

@@ -6,7 +6,7 @@
 VALUE rbs_alias(VALUE typename, VALUE args, VALUE location);
 VALUE rbs_ast_annotation(VALUE string, VALUE location);
 VALUE rbs_ast_comment(VALUE string, VALUE location);
-VALUE rbs_ast_type_param(VALUE name, VALUE variance, bool unchecked, VALUE upper_bound, VALUE location);
+VALUE rbs_ast_type_param(VALUE name, VALUE variance, bool unchecked, VALUE upper_bound, VALUE default_type, VALUE location);
 VALUE rbs_ast_decl_type_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_class_super(VALUE name, VALUE args, VALUE location);
 VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE members, VALUE annotations, VALUE location, VALUE comment);

data/lib/rbs/ast/declarations.rb

@@ -104,6 +104,18 @@ module RBS
           @comment = comment
         end
 
+        def update(name: self.name, type_params: self.type_params, super_class: self.super_class, members: self.members, annotations: self.annotations, location: self.location, comment: self.comment)
+          self.class.new(
+            name: name,
+            type_params: type_params,
+            super_class: super_class,
+            members: members,
+            annotations: annotations,
+            location: location,
+            comment: comment
+          )
+        end
+
         def ==(other)
           other.is_a?(Class) &&
             other.name == name &&
@@ -192,6 +204,19 @@ module RBS
           @comment = comment
         end
 
+        def update(name: self.name, type_params: self.type_params, members: self.members, self_types: self.self_types, annotations: self.annotations, location: self.location, comment: self.comment)
+          self.class.new(
+            name: name,
+            type_params: type_params,
+            members: members,
+            self_types: self_types,
+            annotations: annotations,
+            location: location,
+            comment: comment
+          )
+        end
+
+
         def ==(other)
           other.is_a?(Module) &&
             other.name == name &&
@@ -239,6 +264,17 @@ module RBS
           @comment = comment
         end
 
+        def update(name: self.name, type_params: self.type_params, members: self.members, annotations: self.annotations, location: self.location, comment: self.comment)
+          self.class.new(
+            name: name,
+            type_params: type_params,
+            members: members,
+            annotations: annotations,
+            location: location,
+            comment: comment
+          )
+        end
+
         def ==(other)
           other.is_a?(Interface) &&
             other.name == name &&