Parser inline leading @rbs METHOD-TYPEs annotation

Author: soutaro

ext/rbs_extension/parser.c

@@ -2874,6 +2874,39 @@ static void parse_method_overload(parserstate *state, VALUE *annotations, VALUE
   *method_type = parse_method_type(state);
 }
 
+/**
+ * @brief Parses inline method overload definitions and updates `overloads` and `bar_locations`
+ *
+ * inline_method_overloads ::= {} <overload>                        -- returns true
+ *                           | {} overload `|` ... `|` overload     -- returns true
+ *                           | {<>}                                 -- returns false
+ *
+ *
+ * @param state
+ * @param overloads
+ * @param bar_location
+ */
+static void parse_inline_method_overloads(parserstate *state, VALUE *overloads, VALUE *bar_locations) {
+  while (true) {
+    VALUE annotations = EMPTY_ARRAY;
+    VALUE method_type;
+
+    parse_method_overload(state, &annotations, &method_type);
+
+    VALUE overload = rbs_ast_members_method_definition_overload(annotations, method_type);
+
+    rb_ary_push(*overloads, overload);
+
+    if (state->next_token.type == pBAR) {
+      parser_advance(state);
+      melt_array(bar_locations);
+      rb_ary_push(*bar_locations, rbs_new_location(state->buffer, state->current_token.range));
+    } else {
+      return;
+    }
+  }
+}
+
 static VALUE parse_inline_leading_annotation(parserstate *state) {
   switch (state->next_token.type) {
     case pCOLON: {
@@ -2893,6 +2926,36 @@ static VALUE parse_inline_leading_annotation(parserstate *state) {
         method_type
       );
     }
+    case kATRBS: {
+      range rbs_range = state->next_token.range;
+      parser_advance(state);
+
+      switch (state->next_token.type) {
+        case pLPAREN:
+        case pLBRACKET:
+        case pLBRACE:
+        case tANNOTATION: {
+          VALUE overloads = rb_ary_new();
+          VALUE bar_locations = EMPTY_ARRAY;
+
+          parse_inline_method_overloads(state, &overloads, &bar_locations);
+
+          return rbs_ast_ruby_annotations_method_types_annotation(
+            rbs_new_location(state->buffer, (range) { .start = rbs_range.start, .end = state->current_token.range.end }),
+            rbs_new_location(state->buffer, rbs_range),
+            overloads,
+            bar_locations
+          );
+        }
+        default: {
+          raise_syntax_error(
+            state,
+            state->next_token,
+            "unexpected token for @rbs annotation"
+          );
+        }
+      }
+    }
     default: {
       raise_syntax_error(
         state,

test/rbs/inline_annotation_parsing_test.rb

@@ -45,4 +45,32 @@ def test_parse__colon_method_type_annotation
       assert_equal ["a", "b"], annot.annotations.map(&:string)
     end
   end
+
+  def test_parse__rbs_method_types_annotation
+    Parser.parse_inline_leading_annotation("@rbs %a{a} (String) -> void", 0...).tap do |annot|
+      assert_instance_of AST::Ruby::Annotations::MethodTypesAnnotation, annot
+      assert_equal "@rbs %a{a} (String) -> void", annot.location.source
+      assert_equal "@rbs", annot.prefix_location.source
+      annot.overloads[0].tap do |overload|
+        assert_equal "(String) -> void", overload.method_type.location.source
+        assert_equal ["a"], overload.annotations.map(&:string)
+      end
+      assert_empty annot.vertical_bar_locations
+    end
+
+    Parser.parse_inline_leading_annotation("@rbs %a{a} (String) -> void | [T] (T) -> T", 0...).tap do |annot|
+      assert_instance_of AST::Ruby::Annotations::MethodTypesAnnotation, annot
+      assert_equal "@rbs %a{a} (String) -> void | [T] (T) -> T", annot.location.source
+      assert_equal "@rbs", annot.prefix_location.source
+      annot.overloads[0].tap do |overload|
+        assert_equal "(String) -> void", overload.method_type.location.source
+        assert_equal ["a"], overload.annotations.map(&:string)
+      end
+      annot.overloads[1].tap do |overload|
+        assert_equal "[T] (T) -> T", overload.method_type.location.source
+        assert_equal [], overload.annotations.map(&:string)
+      end
+      assert_equal ["|"], annot.vertical_bar_locations.map(&:source)
+    end
+  end
 end