Let Module self types be a list

Author: soutaro

lib/rbs/ast/declarations.rb

@@ -204,6 +204,44 @@ def to_json(*a)
       end
 
       class Module < Base
+        class Self
+          attr_reader :name
+          attr_reader :args
+          attr_reader :location
+
+          def initialize(name:, args:, location:)
+            @name = name
+            @args = args
+            @location = location
+          end
+
+          def ==(other)
+            other.is_a?(Self) && other.name == name && other.args == args
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ name.hash ^ args.hash ^ location.hash
+          end
+
+          def to_json(*a)
+            {
+              name: name,
+              args: args,
+              location: location
+            }.to_json(*a)
+          end
+
+          def to_s
+            if args.empty?
+              name.to_s
+            else
+              "#{name}[#{args.join(", ")}]"
+            end
+          end
+        end
+
         include NestedDeclarationHelper
         include MixinHelper
 
@@ -212,13 +250,13 @@ class Module < Base
         attr_reader :members
         attr_reader :location
         attr_reader :annotations
-        attr_reader :self_type
+        attr_reader :self_types
         attr_reader :comment
 
-        def initialize(name:, type_params:, members:, self_type:, annotations:, location:, comment:)
+        def initialize(name:, type_params:, members:, self_types:, annotations:, location:, comment:)
           @name = name
           @type_params = type_params
-          @self_type = self_type
+          @self_types = self_types
           @members = members
           @annotations = annotations
           @location = location
@@ -229,14 +267,14 @@ def ==(other)
           other.is_a?(Module) &&
             other.name == name &&
             other.type_params == type_params &&
-            other.self_type == self_type &&
+            other.self_types == self_types &&
             other.members == members
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type_params.hash ^ self_type.hash ^ members.hash
+          self.class.hash ^ name.hash ^ type_params.hash ^ self_types.hash ^ members.hash
         end
 
         def to_json(*a)
@@ -245,7 +283,7 @@ def to_json(*a)
             name: name,
             type_params: type_params,
             members: members,
-            self_type: self_type,
+            self_types: self_types,
             annotations: annotations,
             location: location,
             comment: comment

lib/rbs/definition_builder.rb

@@ -243,11 +243,9 @@ def build_instance(type_name)
           end
 
           if entry.is_a?(Environment::ModuleEntry)
-            if self_type_ancestor = module_self_ancestor(type_name, entry)
-              definition_pairs.push [
-                                      self_type_ancestor,
-                                      build_interface(self_type_ancestor.name)
-                                    ]
+            entry.self_types.each do |module_self|
+              ancestor = Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
+              definition_pairs.push [ancestor, build_interface(module_self.name)]
             end
           end
 
@@ -259,29 +257,6 @@ def build_instance(type_name)
       end
     end
 
-    def module_self_ancestor(type_name, entry)
-      self_decls = entry.decls.select {|d| d.decl.self_type }
-
-      return if self_decls.empty?
-
-      selfs = self_decls.map do |d|
-        Definition::Ancestor::Instance.new(
-          name: d.decl.self_type.name,
-          args: d.decl.self_type.args
-        )
-      end
-
-      selfs.uniq!
-
-      return selfs[0] if selfs.size == 1
-
-      raise ModuleSelfTypeMismatchError.new(
-        name: type_name,
-        entry: entry,
-        location: self_decls[0].decl.location
-      )
-    end
-
     def build_singleton(type_name)
       try_cache type_name, cache: singleton_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"

lib/rbs/environment.rb

@@ -59,14 +59,16 @@ def type_params
     end
 
     class ModuleEntry < MultiEntry
-      def self_type
-        primary.decl.self_type
+      def self_types
+        decls.flat_map do |d|
+          d.decl.self_types
+        end.uniq
       end
 
       def primary
         @primary ||= begin
                        validate_type_params
-                       decls.find {|d| d.decl.self_type } || decls.first
+                       decls.first
                      end
       end
     end
@@ -257,8 +259,12 @@ def resolve_declaration(resolver, decl, outer:, prefix:)
         AST::Declarations::Module.new(
           name: decl.name.with_prefix(prefix),
           type_params: decl.type_params,
-          self_type: decl.self_type&.yield_self do |self_type|
-            absolute_type(resolver, self_type, context: context)
+          self_types: decl.self_types.map do |module_self|
+            AST::Declarations::Module::Self.new(
+              name: absolute_type_name(resolver, module_self.name, context: context),
+              args: module_self.args.map {|type| absolute_type(resolver, type, context: context) },
+              location: module_self.location
+            )
           end,
           members: decl.members.map do |member|
             case member

lib/rbs/errors.rb

@@ -198,20 +198,6 @@ def initialize(name:, super_classes:, entry:)
     end
   end
 
-  class ModuleSelfTypeMismatchError < StandardError
-    attr_reader :name
-    attr_reader :entry
-    attr_reader :location
-
-    def initialize(name:, entry:, location:)
-      @name = name
-      @entry = entry
-      @location = location
-
-      super "#{Location.to_string location}: Module self type mismatch: #{name}"
-    end
-  end
-
   class InconsistentMethodVisibilityError < StandardError
     attr_reader :type_name
     attr_reader :method_name

lib/rbs/parser.y

@@ -106,41 +106,79 @@ rule
       }
 
   module_decl:
-      annotations kMODULE start_new_scope class_name module_type_params module_self_type class_members kEND {
+      annotations kMODULE start_new_scope class_name module_type_params colon_module_self_types class_members kEND {
         reset_variable_scope
 
         location = val[1].location + val[7].location
         result = Declarations::Module.new(
           name: val[3].value,
           type_params: val[4]&.value || Declarations::ModuleTypeParams.empty,
-          self_type: val[5],
+          self_types: val[5],
           members: val[6],
           annotations: val[0],
           location: location,
           comment: leading_comment(val[0].first&.location || location)
         )
       }
-    | annotations kMODULE start_new_scope tUKEYWORD type class_members kEND {
+    | annotations kMODULE start_new_scope tUKEYWORD module_self_types class_members kEND {
         reset_variable_scope
 
         location = val[1].location + val[6].location
         result = Declarations::Module.new(
           name: val[3].value,
           type_params: Declarations::ModuleTypeParams.empty,
-          self_type: val[4],
+          self_types: val[4],
           members: val[5],
           annotations: val[0],
           location: location,
           comment: leading_comment(val[0].first&.location || location)
         )
       }
 
-  module_self_type:
-      { result = nil }
-    | kCOLON type {
+  colon_module_self_types:
+      { result = [] }
+    | kCOLON module_self_types {
         result = val[1]
       }
 
+  module_self_types:
+      module_self_type {
+        result = [val[0]]
+      }
+    | module_self_types kCOMMA module_self_type {
+        result = val[0].push(val[2])
+      }
+
+  module_self_type:
+      qualified_name kLBRACKET type_list kRBRACKET {
+        name = val[0].value
+        args = val[2]
+        location = val[0].location + val[3].location
+
+        case
+        when name.class?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        when name.interface?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        else
+          raise SemanticsError.new("Module self type should be instance or interface", subject: val[0], location: val[0].location)
+        end
+      }
+    | qualified_name {
+        name = val[0].value
+        args = []
+        location = val[0].location
+
+        case
+        when name.class?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        when name.interface?
+          result = Declarations::Module::Self.new(name: name, args: args, location: location)
+        else
+          raise SemanticsError.new("Module self type should be instance or interface", subject: val[0], location: val[0].location)
+        end
+      }
+
   class_members:
       { result = [] }
     | class_members class_member {

lib/rbs/prototype/rb.rb

@@ -81,7 +81,7 @@ def process(node, decls:, comments:, singleton:)
           mod = AST::Declarations::Module.new(
             name: const_to_name(module_name),
             type_params: AST::Declarations::ModuleTypeParams.empty,
-            self_type: nil,
+            self_types: [],
             members: [],
             annotations: [],
             location: nil,

lib/rbs/prototype/rbi.rb

@@ -69,7 +69,7 @@ def push_module(name, comment:)
           members: [],
           annotations: [],
           location: nil,
-          self_type: nil,
+          self_types: [],
           comment: comment
         )
 

lib/rbs/prototype/runtime.rb

@@ -370,7 +370,7 @@ def generate_module(mod)
         decl = AST::Declarations::Module.new(
           name: type_name,
           type_params: AST::Declarations::ModuleTypeParams.empty,
-          self_type: nil,
+          self_types: [],
           members: [],
           annotations: [],
           location: nil,

lib/rbs/writer.rb

@@ -85,8 +85,8 @@ def write_decl(decl)
         puts "end"
 
       when AST::Declarations::Module
-        self_type = if decl.self_type
-                      " : #{decl.self_type}"
+        self_type = unless decl.self_types.empty?
+                      " : #{decl.self_types.join(", ")}"
                     end
 
         write_comment decl.comment

schema/decls.json

@@ -226,15 +226,11 @@
             "$ref": "#/definitions/classMember"
           }
         },
-        "self_type": {
-          "oneOf": [
-            {
-              "$ref": "types.json"
-            },
-            {
-              "type": "null"
-            }
-          ]
+        "self_types": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/moduleSelf"
+          }
         },
         "annotations": {
           "type": "array",
@@ -249,7 +245,22 @@
           "$ref": "location.json"
         }
       },
-      "required": ["declaration", "name", "type_params", "members", "self_type", "annotations", "location", "comment"]
+      "required": ["declaration", "name", "type_params", "members", "self_types", "annotations", "location", "comment"]
+    },
+    "moduleSelf": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "args": {
+          "type": "array",
+          "items": {
+            "$ref": "types.json"
+          }
+        }
+      },
+      "required": ["name", "args"]
     },
     "interfaceMember": {
       "oneOf": [