Merge pull request #2614 from ruby/inline--mixin

Implement mixin in inline RBS declarations

Author: soutaro

Gemfile.lock

@@ -43,7 +43,7 @@ GEM
     drb (2.2.3)
     erb (5.0.2)
     extconf_compile_commands_json (0.0.7)
-    ffi (1.17.2)
+    ffi (1.17.2-aarch64-linux-gnu)
     ffi (1.17.2-arm64-darwin)
     ffi (1.17.2-x86_64-linux-gnu)
     fileutils (1.7.3)
@@ -73,6 +73,8 @@ GEM
     net-smtp (0.5.1)
       net-protocol
     nkf (0.2.0)
+    nokogiri (1.18.8-aarch64-linux-gnu)
+      racc (~> 1.4)
     nokogiri (1.18.8-arm64-darwin)
       racc (~> 1.4)
     nokogiri (1.18.8-x86_64-linux-gnu)
@@ -180,6 +182,7 @@ GEM
     zlib (3.2.1)
 
 PLATFORMS
+  aarch64-linux
   arm64-darwin
   x86_64-linux
 

config.yml

@@ -487,3 +487,13 @@ nodes:
         c_type: rbs_node
       - name: comment_location
         c_type: rbs_location
+  - name: RBS::AST::Ruby::Annotations::TypeApplicationAnnotation
+    fields:
+      - name: prefix_location
+        c_type: rbs_location
+      - name: type_args
+        c_type: rbs_node_list
+      - name: close_bracket_location
+        c_type: rbs_location
+      - name: comma_locations
+        c_type: rbs_location_list

ext/rbs_extension/ast_translation.c

@@ -649,6 +649,22 @@ VALUE rbs_struct_to_ruby_value(rbs_translation_context_t ctx, rbs_node_t *instan
             &h
         );
     }
+    case RBS_AST_RUBY_ANNOTATIONS_TYPE_APPLICATION_ANNOTATION: {
+        rbs_ast_ruby_annotations_type_application_annotation_t *node = (rbs_ast_ruby_annotations_type_application_annotation_t *) instance;
+
+        VALUE h = rb_hash_new();
+        rb_hash_aset(h, ID2SYM(rb_intern("location")), rbs_loc_to_ruby_location(ctx, node->base.location));
+        rb_hash_aset(h, ID2SYM(rb_intern("prefix_location")), rbs_loc_to_ruby_location(ctx, node->prefix_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("type_args")), rbs_node_list_to_ruby_array(ctx, node->type_args));
+        rb_hash_aset(h, ID2SYM(rb_intern("close_bracket_location")), rbs_loc_to_ruby_location(ctx, node->close_bracket_location));
+        rb_hash_aset(h, ID2SYM(rb_intern("comma_locations")), rbs_location_list_to_ruby_array(ctx, node->comma_locations));
+
+        return CLASS_NEW_INSTANCE(
+            RBS_AST_Ruby_Annotations_TypeApplicationAnnotation,
+            1,
+            &h
+        );
+    }
     case RBS_AST_STRING: {
         rbs_ast_string_t *string_node = (rbs_ast_string_t *) instance;
         rbs_string_t s = string_node->string;

ext/rbs_extension/class_constants.c

@@ -54,6 +54,7 @@ VALUE RBS_AST_Ruby_Annotations_MethodTypesAnnotation;
 VALUE RBS_AST_Ruby_Annotations_NodeTypeAssertion;
 VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;
 VALUE RBS_AST_Ruby_Annotations_SkipAnnotation;
+VALUE RBS_AST_Ruby_Annotations_TypeApplicationAnnotation;
 VALUE RBS_AST_TypeParam;
 VALUE RBS_MethodType;
 VALUE RBS_Namespace;
@@ -139,6 +140,7 @@ void rbs__init_constants(void) {
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_NodeTypeAssertion, RBS_AST_Ruby_Annotations, "NodeTypeAssertion");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_ReturnTypeAnnotation, RBS_AST_Ruby_Annotations, "ReturnTypeAnnotation");
     IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_SkipAnnotation, RBS_AST_Ruby_Annotations, "SkipAnnotation");
+    IMPORT_CONSTANT(RBS_AST_Ruby_Annotations_TypeApplicationAnnotation, RBS_AST_Ruby_Annotations, "TypeApplicationAnnotation");
     IMPORT_CONSTANT(RBS_AST_TypeParam, RBS_AST, "TypeParam");
     IMPORT_CONSTANT(RBS_MethodType, RBS, "MethodType");
     IMPORT_CONSTANT(RBS_Namespace, RBS, "Namespace");

ext/rbs_extension/class_constants.h

@@ -60,6 +60,7 @@ extern VALUE RBS_AST_Ruby_Annotations_MethodTypesAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_NodeTypeAssertion;
 extern VALUE RBS_AST_Ruby_Annotations_ReturnTypeAnnotation;
 extern VALUE RBS_AST_Ruby_Annotations_SkipAnnotation;
+extern VALUE RBS_AST_Ruby_Annotations_TypeApplicationAnnotation;
 extern VALUE RBS_AST_TypeParam;
 extern VALUE RBS_MethodType;
 extern VALUE RBS_Namespace;

include/rbs/ast.h

@@ -50,38 +50,39 @@ enum rbs_node_type {
     RBS_AST_RUBY_ANNOTATIONS_NODE_TYPE_ASSERTION = 34,
     RBS_AST_RUBY_ANNOTATIONS_RETURN_TYPE_ANNOTATION = 35,
     RBS_AST_RUBY_ANNOTATIONS_SKIP_ANNOTATION = 36,
-    RBS_AST_STRING = 37,
-    RBS_AST_TYPE_PARAM = 38,
-    RBS_METHOD_TYPE = 39,
-    RBS_NAMESPACE = 40,
-    RBS_SIGNATURE = 41,
-    RBS_TYPE_NAME = 42,
-    RBS_TYPES_ALIAS = 43,
-    RBS_TYPES_BASES_ANY = 44,
-    RBS_TYPES_BASES_BOOL = 45,
-    RBS_TYPES_BASES_BOTTOM = 46,
-    RBS_TYPES_BASES_CLASS = 47,
-    RBS_TYPES_BASES_INSTANCE = 48,
-    RBS_TYPES_BASES_NIL = 49,
-    RBS_TYPES_BASES_SELF = 50,
-    RBS_TYPES_BASES_TOP = 51,
-    RBS_TYPES_BASES_VOID = 52,
-    RBS_TYPES_BLOCK = 53,
-    RBS_TYPES_CLASS_INSTANCE = 54,
-    RBS_TYPES_CLASS_SINGLETON = 55,
-    RBS_TYPES_FUNCTION = 56,
-    RBS_TYPES_FUNCTION_PARAM = 57,
-    RBS_TYPES_INTERFACE = 58,
-    RBS_TYPES_INTERSECTION = 59,
-    RBS_TYPES_LITERAL = 60,
-    RBS_TYPES_OPTIONAL = 61,
-    RBS_TYPES_PROC = 62,
-    RBS_TYPES_RECORD = 63,
-    RBS_TYPES_RECORD_FIELD_TYPE = 64,
-    RBS_TYPES_TUPLE = 65,
-    RBS_TYPES_UNION = 66,
-    RBS_TYPES_UNTYPED_FUNCTION = 67,
-    RBS_TYPES_VARIABLE = 68,
+    RBS_AST_RUBY_ANNOTATIONS_TYPE_APPLICATION_ANNOTATION = 37,
+    RBS_AST_STRING = 38,
+    RBS_AST_TYPE_PARAM = 39,
+    RBS_METHOD_TYPE = 40,
+    RBS_NAMESPACE = 41,
+    RBS_SIGNATURE = 42,
+    RBS_TYPE_NAME = 43,
+    RBS_TYPES_ALIAS = 44,
+    RBS_TYPES_BASES_ANY = 45,
+    RBS_TYPES_BASES_BOOL = 46,
+    RBS_TYPES_BASES_BOTTOM = 47,
+    RBS_TYPES_BASES_CLASS = 48,
+    RBS_TYPES_BASES_INSTANCE = 49,
+    RBS_TYPES_BASES_NIL = 50,
+    RBS_TYPES_BASES_SELF = 51,
+    RBS_TYPES_BASES_TOP = 52,
+    RBS_TYPES_BASES_VOID = 53,
+    RBS_TYPES_BLOCK = 54,
+    RBS_TYPES_CLASS_INSTANCE = 55,
+    RBS_TYPES_CLASS_SINGLETON = 56,
+    RBS_TYPES_FUNCTION = 57,
+    RBS_TYPES_FUNCTION_PARAM = 58,
+    RBS_TYPES_INTERFACE = 59,
+    RBS_TYPES_INTERSECTION = 60,
+    RBS_TYPES_LITERAL = 61,
+    RBS_TYPES_OPTIONAL = 62,
+    RBS_TYPES_PROC = 63,
+    RBS_TYPES_RECORD = 64,
+    RBS_TYPES_RECORD_FIELD_TYPE = 65,
+    RBS_TYPES_TUPLE = 66,
+    RBS_TYPES_UNION = 67,
+    RBS_TYPES_UNTYPED_FUNCTION = 68,
+    RBS_TYPES_VARIABLE = 69,
     RBS_KEYWORD,
     RBS_AST_SYMBOL,
 };
@@ -438,6 +439,15 @@ typedef struct rbs_ast_ruby_annotations_skip_annotation {
     struct rbs_location *comment_location;
 } rbs_ast_ruby_annotations_skip_annotation_t;
 
+typedef struct rbs_ast_ruby_annotations_type_application_annotation {
+    rbs_node_t base;
+
+    struct rbs_location *prefix_location;
+    struct rbs_node_list *type_args;
+    struct rbs_location *close_bracket_location;
+    struct rbs_location_list *comma_locations;
+} rbs_ast_ruby_annotations_type_application_annotation_t;
+
 typedef struct rbs_ast_string {
     rbs_node_t base;
 
@@ -712,6 +722,7 @@ rbs_ast_ruby_annotations_method_types_annotation_t *rbs_ast_ruby_annotations_met
 rbs_ast_ruby_annotations_node_type_assertion_t *rbs_ast_ruby_annotations_node_type_assertion_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_node_t *type);
 rbs_ast_ruby_annotations_return_type_annotation_t *rbs_ast_ruby_annotations_return_type_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_location_t *return_location, rbs_location_t *colon_location, rbs_node_t *return_type, rbs_location_t *comment_location);
 rbs_ast_ruby_annotations_skip_annotation_t *rbs_ast_ruby_annotations_skip_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_location_t *skip_location, rbs_location_t *comment_location);
+rbs_ast_ruby_annotations_type_application_annotation_t *rbs_ast_ruby_annotations_type_application_annotation_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_location_t *prefix_location, rbs_node_list_t *type_args, rbs_location_t *close_bracket_location, rbs_location_list_t *comma_locations);
 rbs_ast_string_t *rbs_ast_string_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_string_t string);
 rbs_ast_type_param_t *rbs_ast_type_param_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_ast_symbol_t *name, rbs_keyword_t *variance, rbs_node_t *upper_bound, rbs_node_t *lower_bound, rbs_node_t *default_type, bool unchecked);
 rbs_method_type_t *rbs_method_type_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_node_list_t *type_params, rbs_node_t *type, rbs_types_block_t *block);

lib/rbs/ast/ruby/annotations.rb

@@ -113,6 +113,29 @@ def map_type_name(&block)
             ) #: self
           end
         end
+
+        class TypeApplicationAnnotation < Base
+          attr_reader :type_args, :close_bracket_location, :comma_locations
+
+          def initialize(location:, prefix_location:, type_args:, close_bracket_location:, comma_locations:)
+            super(location, prefix_location)
+            @type_args = type_args
+            @close_bracket_location = close_bracket_location
+            @comma_locations = comma_locations
+          end
+
+          def map_type_name(&block)
+            mapped_type_args = type_args.map { |type| type.map_type_name { yield _1 } }
+            
+            self.class.new(
+              location:,
+              prefix_location:,
+              type_args: mapped_type_args,
+              close_bracket_location:,
+              comma_locations:
+            ) #: self
+          end
+        end
       end
     end
   end

lib/rbs/ast/ruby/members.rb

@@ -211,6 +211,43 @@ def name_location
             rbs_location(node.name_loc)
           end
         end
+
+        class MixinMember < Base
+          attr_reader :node
+          attr_reader :module_name
+          attr_reader :annotation
+
+          def initialize(buffer, node, module_name, annotation)
+            super(buffer)
+            @node = node
+            @module_name = module_name
+            @annotation = annotation
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_location
+            args = node.arguments or raise
+            first_arg = args.arguments.first or raise
+
+            rbs_location(first_arg.location)
+          end
+
+          def type_args
+            annotation&.type_args || []
+          end
+        end
+
+        class IncludeMember < MixinMember
+        end
+
+        class ExtendMember < MixinMember
+        end
+
+        class PrependMember < MixinMember
+        end
       end
     end
   end

lib/rbs/definition_builder.rb

@@ -606,7 +606,7 @@ def import_methods(definition, module_name, module_methods, interfaces_methods,
 
         methods.each do |method|
           if interface_method_duplicates.include?(method.name)
-            member.is_a?(AST::Members::Include) || member.is_a?(AST::Members::Extend) or raise
+            (member.is_a?(AST::Members::Include) || member.is_a?(AST::Members::Extend)) or raise
 
             raise DuplicatedInterfaceMethodDefinitionError.new(
               type: definition.self_type,

lib/rbs/definition_builder/ancestor_builder.rb

@@ -414,7 +414,60 @@ def mixin_ancestors0(decl, type_name, align_params:, included_modules:, included
             end
           end
         when AST::Ruby::Declarations::Base
-          # noop
+          decl.members.each do |member|
+            case member
+            when AST::Ruby::Members::IncludeMember
+              if included_modules
+                module_name = member.module_name
+                module_args = member.type_args
+
+                # Check if mixing in a class (not allowed)
+                if env.class_decl?(module_name)
+                  raise MixinClassError.new(type_name: type_name, member: member)
+                end
+
+                # Check if module exists
+                module_decl = env.normalized_module_entry(module_name) or raise NoMixinFoundError.new(type_name: module_name, member: member)
+                module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+                module_name = env.normalize_module_name(module_name)
+                included_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              end
+
+            when AST::Ruby::Members::ExtendMember
+              if extended_modules
+                module_name = member.module_name
+                module_args = member.type_args
+
+                # Check if mixing in a class (not allowed)
+                if env.class_decl?(module_name)
+                  raise MixinClassError.new(type_name: type_name, member: member)
+                end
+
+                # Check if module exists
+                module_decl = env.normalized_module_entry(module_name) or raise NoMixinFoundError.new(type_name: module_name, member: member)
+                module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+                module_name = env.normalize_module_name(module_name)
+                extended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              end
+
+            when AST::Ruby::Members::PrependMember
+              if prepended_modules
+                module_name = member.module_name
+                module_args = member.type_args
+
+                # Check if mixing in a class (not allowed)
+                if env.class_decl?(module_name)
+                  raise MixinClassError.new(type_name: type_name, member: member)
+                end
+
+                # Check if module exists
+                module_decl = env.normalized_module_entry(module_name) or raise NoMixinFoundError.new(type_name: module_name, member: member)
+                module_args = AST::TypeParam.normalize_args(module_decl.type_params, module_args)
+                module_name = env.normalize_module_name(module_name)
+                prepended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
+              end
+            end
+          end
         end
       end
 
@@ -484,7 +537,7 @@ def instance_ancestors(type_name, building_ancestors: [])
           included_modules.each do |mod|
             name = mod.name
             arg_types = mod.args
-            mod.source.is_a?(AST::Members::Include) or raise
+            (mod.source.is_a?(AST::Members::Include) || mod.source.is_a?(AST::Ruby::Members::IncludeMember)) or raise
             mod_ancestors =
               instance_ancestors(name, building_ancestors: building_ancestors)
                 .apply(arg_types, env: env, location: mod.source.location)
@@ -499,7 +552,7 @@ def instance_ancestors(type_name, building_ancestors: [])
           prepended_modules.each do |mod|
             name = mod.name
             arg_types = mod.args
-            mod.source.is_a?(AST::Members::Prepend) or raise
+            (mod.source.is_a?(AST::Members::Prepend) || mod.source.is_a?(AST::Ruby::Members::PrependMember)) or raise
             mod_ancestors =
               instance_ancestors(name, building_ancestors: building_ancestors)
                 .apply(arg_types, env: env, location: mod.source.location)
@@ -554,7 +607,7 @@ def singleton_ancestors(type_name, building_ancestors: [])
         extended_modules.each do |mod|
           name = mod.name
           args = mod.args
-          mod.source.is_a?(AST::Members::Extend) or raise
+          (mod.source.is_a?(AST::Members::Extend) || mod.source.is_a?(AST::Ruby::Members::ExtendMember)) or raise
           mod_ancestors =
             instance_ancestors(name, building_ancestors: building_ancestors)
               .apply(args, env: env, location: mod.source.location)