rbs 3.4.4 → 3.5.1

data/ext/rbs_extension/parser.c

@@ -52,6 +52,10 @@ typedef struct {
   VALUE rest_keywords;
 } method_params;
 
+static bool rbs_is_untyped_params(method_params *params) {
+  return NIL_P(params->required_positionals);
+}
+
 // /**
 //  * Returns RBS::Location object of `current_token` of a parser state.
 //  *
@@ -78,7 +82,7 @@ static VALUE string_of_loc(parserstate *state, position start, position end) {
 }
 
 /**
- * Raises RuntimeError with "Unexpected error " messsage.
+ * Raises RuntimeError with "Unexpected error " message.
  * */
 static NORETURN(void) rbs_abort(void) {
   rb_raise(
@@ -265,6 +269,7 @@ static VALUE parse_function_param(parserstate *state) {
 
     VALUE location = rbs_new_location(state->buffer, param_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 1);
     rbs_loc_add_optional_child(loc, rb_intern("name"), NULL_RANGE);
 
     return rbs_function_param(type, Qnil, location);
@@ -287,6 +292,7 @@ static VALUE parse_function_param(parserstate *state) {
     VALUE name = rb_to_symbol(rbs_unquote_string(state, state->current_token.range, 0));
     VALUE location = rbs_new_location(state->buffer, param_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 1);
     rbs_loc_add_optional_child(loc, rb_intern("name"), name_range);
 
     return rbs_function_param(type, name, location);
@@ -360,6 +366,7 @@ static bool is_keyword(parserstate *state) {
 
 /*
   params ::= {} `)`
+           | {} `?` `)`               -- Untyped function params (assign params.required = nil)
            | <required_params> `)`
            | <required_params> `,` `)`
 
@@ -387,6 +394,11 @@ static bool is_keyword(parserstate *state) {
              | {} `**` <function_param>
 */
 static void parse_params(parserstate *state, method_params *params) {
+  if (state->next_token.type == pQUESTION && state->next_token2.type == pRPAREN) {
+    params->required_positionals = Qnil;
+    parser_advance(state);
+    return;
+  }
   if (state->next_token.type == pRPAREN) {
     return;
   }
@@ -611,6 +623,13 @@ static void parse_function(parserstate *state, VALUE *function, VALUE *block, VA
     parser_advance_assert(state, pRPAREN);
   }
 
+  // Untyped method parameter means it cannot have block
+  if (rbs_is_untyped_params(&params)) {
+    if (state->next_token.type != pARROW) {
+      raise_syntax_error(state, state->next_token2, "A method type with untyped method parameter cannot have block");
+    }
+  }
+
   // Passing NULL to function_self_type means the function itself doesn't accept self type binding. (== method type)
   if (function_self_type) {
     *function_self_type = parse_self_type_binding(state);
@@ -639,8 +658,11 @@ static void parse_function(parserstate *state, VALUE *function, VALUE *block, VA
     parser_advance_assert(state, pARROW);
     VALUE block_return_type = parse_optional(state);
 
-    *block = rbs_block(
-      rbs_function(
+    VALUE block_function = Qnil;
+    if (rbs_is_untyped_params(&block_params)) {
+      block_function = rbs_untyped_function(block_return_type);
+    } else {
+      block_function = rbs_function(
         block_params.required_positionals,
         block_params.optional_positionals,
         block_params.rest_positionals,
@@ -649,10 +671,10 @@ static void parse_function(parserstate *state, VALUE *function, VALUE *block, VA
         block_params.optional_keywords,
         block_params.rest_keywords,
         block_return_type
-      ),
-      required,
-      block_self_type
-    );
+      );
+    }
+
+    *block = rbs_block(block_function, required, block_self_type);
 
     parser_advance_assert(state, pRBRACE);
   }
@@ -660,16 +682,20 @@ static void parse_function(parserstate *state, VALUE *function, VALUE *block, VA
   parser_advance_assert(state, pARROW);
   VALUE type = parse_optional(state);
 
-  *function = rbs_function(
-    params.required_positionals,
-    params.optional_positionals,
-    params.rest_positionals,
-    params.trailing_positionals,
-    params.required_keywords,
-    params.optional_keywords,
-    params.rest_keywords,
-    type
-  );
+  if (rbs_is_untyped_params(&params)) {
+    *function = rbs_untyped_function(type);
+  } else {
+    *function = rbs_function(
+      params.required_positionals,
+      params.optional_positionals,
+      params.rest_positionals,
+      params.trailing_positionals,
+      params.required_keywords,
+      params.optional_keywords,
+      params.rest_keywords,
+      type
+    );
+  }
 }
 
 /*
@@ -698,15 +724,22 @@ static VALUE parse_proc_type(parserstate *state) {
                      | {} literal_type `=>` <type>
 */
 VALUE parse_record_attributes(parserstate *state) {
-  VALUE hash = rb_hash_new();
+  VALUE fields = rb_hash_new();
 
   if (state->next_token.type == pRBRACE) {
-    return hash;
+    return fields;
   }
 
   while (true) {
-    VALUE key;
-    VALUE type;
+    VALUE key, type,
+          value = rb_ary_new(),
+          required = Qtrue;
+
+    if (state->next_token.type == pQUESTION) {
+      // { ?foo: type } syntax
+      required = Qfalse;
+      parser_advance(state);
+    }
 
     if (is_keyword(state)) {
       // { foo: type } syntax
@@ -735,7 +768,9 @@ VALUE parse_record_attributes(parserstate *state) {
       parser_advance_assert(state, pFATARROW);
     }
     type = parse_type(state);
-    rb_hash_aset(hash, key, type);
+    rb_ary_push(value, type);
+    rb_ary_push(value, required);
+    rb_hash_aset(fields, key, value);
 
     if (parser_advance_if(state, pCOMMA)) {
       if (state->next_token.type == pRBRACE) {
@@ -745,8 +780,7 @@ VALUE parse_record_attributes(parserstate *state) {
       break;
     }
   }
-
-  return hash;
+  return fields;
 }
 
 /*
@@ -832,6 +866,7 @@ static VALUE parse_instance_type(parserstate *state, bool parse_alias) {
 
     VALUE location = rbs_new_location(state->buffer, type_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 2);
     rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
     rbs_loc_add_optional_child(loc, rb_intern("args"), args_range);
 
@@ -866,6 +901,7 @@ static VALUE parse_singleton_type(parserstate *state) {
 
   VALUE location = rbs_new_location(state->buffer, type_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 1);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
 
   return rbs_class_singleton(typename, location);
@@ -1121,6 +1157,7 @@ VALUE parse_type_params(parserstate *state, range *rg, bool module_type_params)
 
       VALUE location = rbs_new_location(state->buffer, param_range);
       rbs_loc *loc = rbs_check_location(location);
+      rbs_loc_alloc_children(loc, 4);
       rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
       rbs_loc_add_optional_child(loc, rb_intern("variance"), variance_range);
       rbs_loc_add_optional_child(loc, rb_intern("unchecked"), unchecked_range);
@@ -1181,6 +1218,7 @@ VALUE parse_method_type(parserstate *state) {
 
   VALUE location = rbs_new_location(state->buffer, rg);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 2);
   rbs_loc_add_required_child(loc, rb_intern("type"), type_range);
   rbs_loc_add_optional_child(loc, rb_intern("type_params"), params_range);
 
@@ -1220,6 +1258,7 @@ VALUE parse_global_decl(parserstate *state) {
 
   location = rbs_new_location(state->buffer, decl_range);
   loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 2);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
 
@@ -1253,6 +1292,7 @@ VALUE parse_const_decl(parserstate *state) {
 
   location = rbs_new_location(state->buffer, decl_range);
   loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 2);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
 
@@ -1286,6 +1326,7 @@ VALUE parse_type_decl(parserstate *state, position comment_pos, VALUE annotation
 
   VALUE location = rbs_new_location(state->buffer, decl_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 4);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_optional_child(loc, rb_intern("type_params"), params_range);
@@ -1627,6 +1668,7 @@ VALUE parse_member_def(parserstate *state, bool instance_only, bool accept_overl
 
   VALUE location = rbs_new_location(state->buffer, member_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 5);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_optional_child(loc, rb_intern("kind"), kind_range);
@@ -1731,6 +1773,7 @@ VALUE parse_mixin_member(parserstate *state, bool from_interface, position comme
 
   VALUE location = rbs_new_location(state->buffer, member_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 3);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_optional_child(loc, rb_intern("args"), args_range);
@@ -1794,6 +1837,7 @@ VALUE parse_alias_member(parserstate *state, bool instance_only, position commen
   member_range.end = state->current_token.range.end;
   VALUE location = rbs_new_location(state->buffer, member_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 5);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("new_name"), new_name_range);
   rbs_loc_add_required_child(loc, rb_intern("old_name"), old_name_range);
@@ -1897,6 +1941,7 @@ VALUE parse_variable_member(parserstate *state, position comment_pos, VALUE anno
 
   location = rbs_new_location(state->buffer, member_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 3);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
   rbs_loc_add_optional_child(loc, rb_intern("kind"), kind_range);
@@ -2041,6 +2086,7 @@ VALUE parse_attribute_member(parserstate *state, position comment_pos, VALUE ann
 
   location = rbs_new_location(state->buffer, member_range);
   loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 7);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("colon"), colon_range);
@@ -2138,6 +2184,7 @@ VALUE parse_interface_decl(parserstate *state, position comment_pos, VALUE annot
 
   VALUE location = rbs_new_location(state->buffer, member_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 4);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("end"), end_range);
@@ -2183,6 +2230,7 @@ void parse_module_self_types(parserstate *state, VALUE array) {
 
     VALUE location = rbs_new_location(state->buffer, self_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 2);
     rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
     rbs_loc_add_optional_child(loc, rb_intern("args"), args_range);
 
@@ -2319,6 +2367,7 @@ VALUE parse_module_decl0(parserstate *state, range keyword_range, VALUE module_n
 
   VALUE location = rbs_new_location(state->buffer, decl_range);
   rbs_loc *loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 6);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("end"), end_range);
@@ -2368,6 +2417,7 @@ VALUE parse_module_decl(parserstate *state, position comment_pos, VALUE annotati
 
     VALUE location = rbs_new_location(state->buffer, decl_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 4);
     rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
     rbs_loc_add_required_child(loc, rb_intern("new_name"), module_name_range);
     rbs_loc_add_required_child(loc, rb_intern("eq"), eq_range);
@@ -2404,6 +2454,7 @@ VALUE parse_class_decl_super(parserstate *state, range *lt_range) {
 
     location = rbs_new_location(state->buffer, super_range);
     loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 2);
     rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
     rbs_loc_add_optional_child(loc, rb_intern("args"), args_range);
 
@@ -2446,6 +2497,7 @@ VALUE parse_class_decl0(parserstate *state, range keyword_range, VALUE name, ran
 
   location = rbs_new_location(state->buffer, decl_range);
   loc = rbs_check_location(location);
+  rbs_loc_alloc_children(loc, 5);
   rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
   rbs_loc_add_required_child(loc, rb_intern("name"), name_range);
   rbs_loc_add_required_child(loc, rb_intern("end"), end_range);
@@ -2491,6 +2543,7 @@ VALUE parse_class_decl(parserstate *state, position comment_pos, VALUE annotatio
 
     VALUE location = rbs_new_location(state->buffer, decl_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 4);
     rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
     rbs_loc_add_required_child(loc, rb_intern("new_name"), class_name_range);
     rbs_loc_add_required_child(loc, rb_intern("eq"), eq_range);
@@ -2664,6 +2717,7 @@ void parse_use_clauses(parserstate *state, VALUE clauses) {
 
         VALUE location = rbs_new_location(state->buffer, clause_range);
         rbs_loc *loc = rbs_check_location(location);
+        rbs_loc_alloc_children(loc, 3);
         rbs_loc_add_required_child(loc, rb_intern("type_name"), type_name_range);
         rbs_loc_add_optional_child(loc, rb_intern("keyword"), keyword_range);
         rbs_loc_add_optional_child(loc, rb_intern("new_name"), new_name_range);
@@ -2681,6 +2735,7 @@ void parse_use_clauses(parserstate *state, VALUE clauses) {
 
         VALUE location = rbs_new_location(state->buffer, clause_range);
         rbs_loc *loc = rbs_check_location(location);
+        rbs_loc_alloc_children(loc, 2);
         rbs_loc_add_required_child(loc, rb_intern("namespace"), namespace_range);
         rbs_loc_add_required_child(loc, rb_intern("star"), star_range);
 
@@ -2723,6 +2778,7 @@ VALUE parse_use_directive(parserstate *state) {
 
     VALUE location = rbs_new_location(state->buffer, directive_range);
     rbs_loc *loc = rbs_check_location(location);
+    rbs_loc_alloc_children(loc, 1);
     rbs_loc_add_required_child(loc, rb_intern("keyword"), keyword_range);
 
     return rbs_ast_directives_use(clauses, location);
@@ -2749,54 +2805,103 @@ VALUE parse_signature(parserstate *state) {
   return ret;
 }
 
+struct parse_type_arg {
+  parserstate *parser;
+  VALUE require_eof;
+};
+
 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);
+ensure_free_parser(VALUE parser) {
+  free_parser((parserstate *)parser);
+  return Qnil;
+}
+
+static VALUE
+parse_type_try(VALUE a) {
+  struct parse_type_arg *arg = (struct parse_type_arg *)a;
 
-  if (parser->next_token.type == pEOF) {
+  if (arg->parser->next_token.type == pEOF) {
     return Qnil;
   }
 
-  VALUE type = parse_type(parser);
+  VALUE type = parse_type(arg->parser);
 
-  if (RB_TEST(require_eof)) {
-    parser_advance_assert(parser, pEOF);
+  if (RB_TEST(arg->require_eof)) {
+    parser_advance_assert(arg->parser, pEOF);
   }
 
-  free_parser(parser);
-
   return type;
 }
 
 static VALUE
-rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, VALUE variables, VALUE require_eof)
+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);
+  struct parse_type_arg arg = {
+    parser,
+    require_eof
+  };
+  return rb_ensure(parse_type_try, (VALUE)&arg, ensure_free_parser, (VALUE)parser);
+}
 
-  if (parser->next_token.type == pEOF) {
+static VALUE
+parse_method_type_try(VALUE a) {
+  struct parse_type_arg *arg = (struct parse_type_arg *)a;
+
+  if (arg->parser->next_token.type == pEOF) {
     return Qnil;
   }
 
-  VALUE method_type = parse_method_type(parser);
+  VALUE method_type = parse_method_type(arg->parser);
 
-  if (RB_TEST(require_eof)) {
-    parser_advance_assert(parser, pEOF);
+  if (RB_TEST(arg->require_eof)) {
+    parser_advance_assert(arg->parser, pEOF);
   }
 
-  free_parser(parser);
-
   return method_type;
 }
 
+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);
+  struct parse_type_arg arg = {
+    parser,
+    require_eof
+  };
+  return rb_ensure(parse_method_type_try, (VALUE)&arg, ensure_free_parser, (VALUE)parser);
+}
+
+static VALUE
+parse_signature_try(VALUE a) {
+  parserstate *parser = (parserstate *)a;
+  return parse_signature(parser);
+}
+
 static VALUE
 rbsparser_parse_signature(VALUE self, VALUE buffer, VALUE end_pos)
 {
   parserstate *parser = alloc_parser(buffer, 0, FIX2INT(end_pos), Qnil);
-  VALUE pair = parse_signature(parser);
-  free_parser(parser);
+  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 results = rb_ary_new();
+
+  token token = NullToken;
+  while (token.type != pEOF) {
+    token = rbsparser_next_token(lexer);
+    VALUE type = ID2SYM(rb_intern(token_type_str(token.type)));
+    VALUE location = rbs_new_location(buffer, token.range);
+    VALUE pair = rb_ary_new3(2, type, location);
+    rb_ary_push(results, pair);
+  }
+
+  free(lexer);
 
-  return pair;
+  return results;
 }
 
 void rbs__init_parser(void) {
@@ -2804,4 +2909,5 @@ void rbs__init_parser(void) {
   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);
+  rb_define_singleton_method(RBS_Parser, "_lex", rbsparser_lex, 2);
 }

data/ext/rbs_extension/parserstate.c

@@ -109,6 +109,8 @@ void parser_advance(parserstate *state) {
       // skip
     } else if (state->next_token3.type == tLINECOMMENT) {
       insert_comment_line(state, state->next_token3);
+    } else if (state->next_token3.type == tTRIVIA) {
+      //skip
     } else {
       break;
     }
@@ -272,11 +274,15 @@ VALUE comment_to_ruby(comment *com, VALUE buffer) {
   );
 }
 
-parserstate *alloc_parser(VALUE buffer, int start_pos, int end_pos, VALUE variables) {
+lexstate *alloc_lexer(VALUE buffer, int start_pos, int end_pos) {
   VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
 
   StringValue(string);
 
+  if (start_pos < 0 || end_pos < 0) {
+    rb_raise(rb_eArgError, "negative position range: %d...%d", start_pos, end_pos);
+  }
+
   lexstate *lexer = calloc(1, sizeof(lexstate));
   lexer->string = string;
   lexer->current.line = 1;
@@ -286,6 +292,11 @@ parserstate *alloc_parser(VALUE buffer, int start_pos, int end_pos, VALUE variab
   lexer->start = lexer->current;
   lexer->first_token_of_line = lexer->current.column == 0;
 
+  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 *parser = calloc(1, sizeof(parserstate));
   parser->lexstate = lexer;
   parser->buffer = buffer;

data/ext/rbs_extension/parserstate.h

@@ -93,6 +93,15 @@ void parser_insert_typevar(parserstate *state, ID id);
  * */
 bool parser_typevar_member(parserstate *state, ID id);
 
+/**
+ * Allocate new lexstate object.
+ *
+ * ```
+ * alloc_lexer(buffer, 0, 31)    // New lexstate with buffer
+ * ```
+ * */
+lexstate *alloc_lexer(VALUE buffer, int start_pos, int end_pos);
+
 /**
  * Allocate new parserstate object.
  *

data/ext/rbs_extension/ruby_objs.c

@@ -170,6 +170,17 @@ VALUE rbs_function_param(VALUE type, VALUE name, VALUE location) {
   );
 }
 
+VALUE rbs_untyped_function(VALUE return_type) {
+  VALUE args = rb_hash_new();
+  rb_hash_aset(args, ID2SYM(rb_intern("return_type")), return_type);
+
+  return CLASS_NEW_INSTANCE(
+    RBS_Types_UntypedFunction,
+    1,
+    &args
+  );
+}
+
 VALUE rbs_function(
   VALUE required_positional_params,
   VALUE optional_positional_params,
@@ -234,10 +245,10 @@ VALUE rbs_literal(VALUE literal, VALUE location) {
   );
 }
 
-VALUE rbs_record(VALUE fields, VALUE location) {
+VALUE rbs_record(VALUE fields,VALUE location) {
   VALUE args = rb_hash_new();
   rb_hash_aset(args, ID2SYM(rb_intern("location")), location);
-  rb_hash_aset(args, ID2SYM(rb_intern("fields")), fields);
+  rb_hash_aset(args, ID2SYM(rb_intern("all_fields")), fields);
 
   return CLASS_NEW_INSTANCE(
     RBS_Types_Record,
@@ -588,4 +599,3 @@ VALUE rbs_ast_directives_use_wildcard_clause(VALUE namespace, VALUE location) {
 
   return CLASS_NEW_INSTANCE(RBS_AST_Directives_Use_WildcardClause, 1, &kwargs);
 }
-

data/ext/rbs_extension/ruby_objs.h

@@ -30,6 +30,7 @@ VALUE rbs_class_instance(VALUE typename, VALUE type_args, VALUE location);
 VALUE rbs_class_singleton(VALUE typename, VALUE location);
 VALUE rbs_function_param(VALUE type, VALUE name, VALUE location);
 VALUE rbs_function(VALUE required_positional_params, VALUE optional_positional_params, VALUE rest_positional_params, VALUE trailing_positional_params, VALUE required_keywords, VALUE optional_keywords, VALUE rest_keywords, VALUE return_type);
+VALUE rbs_untyped_function(VALUE return_type);
 VALUE rbs_interface(VALUE typename, VALUE type_args, VALUE location);
 VALUE rbs_intersection(VALUE types, VALUE location);
 VALUE rbs_literal(VALUE literal, VALUE location);

data/lib/rbs/cli/validate.rb

@@ -66,8 +66,8 @@ Examples:
   $ rbs validate
 EOU
 
-          opts.on("--silent") do
-            RBS.print_warning { "`--silent` option is deprecated." }
+          opts.on("--silent", "This option has been deprecated and does nothing.") do
+            RBS.print_warning { "`--silent` option is deprecated because it's silent by default. You can use --log-level option of rbs command to display more information." }
           end
           opts.on("--[no-]exit-error-on-syntax-error", "exit(1) if syntax error is detected") {|bool|
             exit_error = bool

data/lib/rbs/cli.rb

@@ -3,7 +3,6 @@
 require "open3"
 require "optparse"
 require "shellwords"
-require "abbrev"
 require "stringio"
 
 module RBS
@@ -1062,14 +1061,13 @@ EOB
       config_path = options.config_path or raise
       lock_path = Collection::Config.to_lockfile_path(config_path)
 
-      subcommand = Abbrev.abbrev(['install', 'update', 'help'])[args[0]] || args[0]
-      case subcommand
-      when 'install'
+      case args[0]
+      when 'install', 'instal', 'insta', 'inst', 'ins', 'in', 'i'
         unless params[:frozen]
           Collection::Config.generate_lockfile(config_path: config_path, definition: Bundler.definition)
         end
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
-      when 'update'
+      when 'update', 'updat', 'upda', 'upd', 'up', 'u'
         # TODO: Be aware of argv to update only specified gem
         Collection::Config.generate_lockfile(config_path: config_path, definition: Bundler.definition, with_lockfile: false)
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
@@ -1107,7 +1105,7 @@ EOB
           exit 1
         end
         Collection::Cleaner.new(lockfile_path: lock_path)
-      when 'help'
+      when 'help', 'hel', 'he', 'h'
         puts opts.help
       else
         puts opts.help

data/lib/rbs/collection/config.rb

@@ -65,8 +65,8 @@ module RBS
 
       def sources
         @sources ||= [
-          Sources::Stdlib.instance,
           Sources::Rubygems.instance,
+          Sources::Stdlib.instance,
           *@data['sources'].map { |c| Sources.from_config_entry(c, base_directory: @config_path.dirname) }
         ]
       end

data/lib/rbs/collection/sources/git.rb

@@ -152,12 +152,7 @@ module RBS
         private def need_to_fetch?(revision)
           return true unless commit_hash?
 
-          begin
-            git('cat-file', '-e', revision)
-            false
-          rescue CommandError
-            true
-          end
+          !git?('cat-file', '-e', revision)
         end
 
         private def git_dir

data/lib/rbs/definition_builder/method_builder.rb

@@ -4,7 +4,7 @@ module RBS
   class DefinitionBuilder
     class MethodBuilder
       class Methods
-        Definition = _ = Struct.new(:name, :type, :originals, :overloads, :accessibilities, keyword_init: true) do
+        class Definition < Struct.new(:name, :type, :originals, :overloads, :accessibilities, keyword_init: true)
           # @implements Definition
 
           def original