Support auto extending module

In Ruby language, developers need to use both "include" and "extend" to
implement mix-in having instance methods and class methods.  The auto
extending module is a well-known technique to realize it (ex.
`ActiveSupport::Concern`, "extend" call in `included` block, and so on).

This supports the auto extending modules via modules having
"autoextend:..." annotation.  The `RBS::DefinitionBuilder` searches the
extended modules from the annotations of the included modules.

Author: tk0miya

docs/syntax.md

@@ -780,3 +780,17 @@ _annotation_ ::= `%a{` _annotation-text_ `}`  # Annotation using {}
 
 _annotation-text_ ::= /[^\x00]*/              # Any characters except NUL (and parenthesis)
 ```
+
+#### Auto extending modules
+
+Module having "autoextend:..." annotation is considered as an auto extending module.
+When such auto extending modules are included, the including class will be extended by annotated modules.
+
+```
+%a{autoextend:Mod::ClassMethods}
+module Mod
+  module ClassMethods
+    def foo: () -> void
+  end
+end
+```

lib/rbs/definition_builder.rb

@@ -239,6 +239,19 @@ def build_singleton0(type_name)
             definition.class_variables.merge!(defn.class_variables)
           end
 
+          one_ancestors.each_included_module do |mod|
+            included_module = env.class_decls[mod.name] or raise "Unknown name for one_ancestors.included_module: #{type_name}"
+            included_module.decls.each do |decl|
+              decl.decl.annotations.each do |annotation|
+                if annotation.string.start_with? "autoextend:"
+                  mod_name = TypeName("::" + annotation.string.split(":", 2)[1])
+                  subst = tapp_subst(mod_name, [])
+                  define_instance(definition, mod_name, subst)
+                end
+              end
+            end
+          end
+
           one_ancestors.each_extended_module do |mod|
             mod.args.each do |arg|
               validate_type_presence(arg)

lib/rbs/definition_builder/ancestor_builder.rb

@@ -111,7 +111,7 @@ def self.singleton(type_name:, super_class:)
             params: nil,
             super_class: super_class,
             self_types: nil,
-            included_modules: nil,
+            included_modules: [],
             included_interfaces: nil,
             prepended_modules: nil,
             extended_modules: [],
@@ -306,7 +306,7 @@ def one_singleton_ancestors(type_name)
 
         mixin_ancestors(entry,
                         type_name,
-                        included_modules: nil,
+                        included_modules: ancestors.included_modules,
                         included_interfaces: nil,
                         prepended_modules: nil,
                         extended_modules: ancestors.extended_modules,

test/rbs/definition_builder_test.rb

@@ -281,6 +281,37 @@ def get: () -> X
     end
   end
 
+  def test_build_singleton_including_autoextending_module
+    SignatureManager.new do |manager|
+      manager.files[Pathname("foo.rbs")] = <<EOF
+%a{autoextend:Mod::ClassMethods}
+module Mod
+  module ClassMethods
+    def count: -> Integer
+  end
+end
+
+class Class
+  include Mod
+end
+EOF
+      manager.build do |env|
+        builder = DefinitionBuilder.new(env: env)
+
+        builder.build_singleton(type_name("::Class")).yield_self do |definition|
+          assert_instance_of Definition, definition
+
+          assert_equal [:__id__, :count, :initialize, :new, :puts, :respond_to_missing?, :to_i], definition.methods.keys.sort
+          assert_method_definition definition.methods[:__id__], ["() -> ::Integer"]
+          assert_method_definition definition.methods[:initialize], ["() -> void"]
+          assert_method_definition definition.methods[:puts], ["(*untyped) -> nil"]
+          assert_method_definition definition.methods[:respond_to_missing?], ["(::Symbol, bool) -> bool"]
+        end
+      end
+    end
+  end
+
+
   def test_build_instance_module_include_module
     SignatureManager.new do |manager|
       manager.files[Pathname("foo.rbs")] = <<EOF