rbs 3.4.4 → 3.5.0.pre.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);
@@ -2755,6 +2811,7 @@ rbsparser_parse_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end_pos, V
   parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
 
   if (parser->next_token.type == pEOF) {
+    free_parser(parser);
     return Qnil;
   }
 
@@ -2775,6 +2832,7 @@ rbsparser_parse_method_type(VALUE self, VALUE buffer, VALUE start_pos, VALUE end
   parserstate *parser = alloc_parser(buffer, FIX2INT(start_pos), FIX2INT(end_pos), variables);
 
   if (parser->next_token.type == pEOF) {
+    free_parser(parser);
     return Qnil;
   }
 

data/ext/rbs_extension/parserstate.c

@@ -277,6 +277,10 @@ parserstate *alloc_parser(VALUE buffer, int start_pos, int end_pos, VALUE variab
 
   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;

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/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

data/lib/rbs/definition_builder.rb

@@ -630,12 +630,12 @@ module RBS
         end
 
         # @type var accessibility: RBS::Definition::accessibility
-        accessibility = if method.name == :initialize
-                          :private
-                        else
-                          method.accessibility
-                        end
-
+        accessibility =
+          if original.instance? && [:initialize, :initialize_copy, :initialize_clone, :initialize_dup, :respond_to_missing?].include?(method.name)
+            :private
+          else
+            method.accessibility
+          end
         # Skip setting up `super_method` if `implemented_in` is `nil`, that means the type doesn't have implementation.
         # This typically happens if the type is an interface.
         if implemented_in
@@ -669,7 +669,7 @@ module RBS
                 ]
               ),
               block: nil,
-              location: nil
+              location: original.location
             )
           else
             # getter
@@ -677,7 +677,7 @@ module RBS
               type_params: [],
               type: Types::Function.empty(attr_type),
               block: nil,
-              location: nil
+              location: original.location
             )
           end
 

data/lib/rbs/diff.rb

@@ -83,7 +83,7 @@ module RBS
         manifest_pathname = dir_pathname / 'manifest.yaml'
         if manifest_pathname.exist?
           manifest = YAML.safe_load(manifest_pathname.read)
-          if manifest['dependencies']
+          if manifest && manifest['dependencies']
             manifest['dependencies'].each do |dependency|
               loader.add(library: dependency['name'], version: nil)
             end

data/lib/rbs/environment_loader.rb

@@ -14,7 +14,8 @@ module RBS
 
     include FileFinder
 
-    Library = _ = Struct.new(:name, :version, keyword_init: true)
+    class Library < Struct.new(:name, :version, keyword_init: true)
+    end
 
     attr_reader :core_root
     attr_reader :repository

data/lib/rbs/errors.rb

@@ -62,20 +62,6 @@ module RBS
 
       super "#{Location.to_string location}: Syntax error: #{error_message}, token=`#{location.source}` (#{token_type})"
     end
-
-    def error_value
-      RBS.print_warning {
-        "#{self.class.name}#error_value is deprecated and will be deleted in RBS 2.0. Consider using `location.source` instead."
-      }
-      location.source
-    end
-
-    def token_str
-      RBS.print_warning {
-        "#{self.class.name}#token_str is deprecated and will be deleted in RBS 2.0. Consider using `token_type` instead."
-      }
-      token_type
-    end
   end
 
   class InvalidTypeApplicationError < DefinitionError

data/lib/rbs/parser_aux.rb

@@ -28,11 +28,6 @@ module RBS
       end
     end
 
-    autoload :SyntaxError, "rbs/parser_compat/syntax_error"
-    autoload :SemanticsError, "rbs/parser_compat/semantics_error"
-    autoload :LexerError, "rbs/parser_compat/lexer_error"
-    autoload :LocatedValue, "rbs/parser_compat/located_value"
-
     KEYWORDS = %w(
       bool
       bot

data/lib/rbs/prototype/helpers.rb

@@ -37,13 +37,9 @@ module RBS
             end
           end
 
-          method_block = Types::Block.new(
-            required: required,
-            type: Types::Function.empty(untyped),
-            self_type: nil
-          )
-
           if yields
+            function = Types::Function.empty(untyped)
+
             yields.each do |yield_node|
               array_content = yield_node.children[0]&.children&.compact || []
 
@@ -54,9 +50,9 @@ module RBS
                                         [array_content, nil]
                                       end
 
-              if (diff = positionals.size - method_block.type.required_positionals.size) > 0
+              if (diff = positionals.size - function.required_positionals.size) > 0
                 diff.times do
-                  method_block.type.required_positionals << Types::Function::Param.new(
+                  function.required_positionals << Types::Function::Param.new(
                     type: untyped,
                     name: nil
                   )
@@ -67,7 +63,7 @@ module RBS
                 keywords.children[0].children.each_slice(2) do |key_node, value_node|
                   if key_node
                     key = key_node.children[0]
-                    method_block.type.required_keywords[key] ||=
+                    function.required_keywords[key] ||=
                       Types::Function::Param.new(
                         type: untyped,
                         name: nil
@@ -76,10 +72,13 @@ module RBS
                 end
               end
             end
+          else
+            function = Types::UntypedFunction.new(return_type: untyped)
           end
-        end
 
-        method_block
+
+          Types::Block.new(required: required, type: function, self_type: nil)
+        end
       end
 
       def each_child(node, &block)
@@ -109,7 +108,7 @@ module RBS
       def keyword_hash?(node)
         if node && node.type == :HASH
           node.children[0].children.compact.each_slice(2).all? {|key, _|
-            key.type == :LIT && key.children[0].is_a?(Symbol)
+            symbol_literal_node?(key)
           }
         else
           false
@@ -122,6 +121,17 @@ module RBS
         args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
       end
 
+      def symbol_literal_node?(node)
+        case node.type
+        when :LIT
+          if node.children[0].is_a?(Symbol)
+            node.children[0]
+          end
+        when :SYM
+          node.children[0]
+        end
+      end
+
       def untyped
         @untyped ||= Types::Bases::Any.new(location: nil)
       end