rbs 3.9.4 → 4.2.0

data/lib/rbs/definition_builder.rb

@@ -124,12 +124,15 @@ module RBS
       end
 
       entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
-      args = entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
 
-      entry.decls.each do |d|
-        subst_ = subst + Substitution.build(d.decl.type_params.each.map(&:name), args)
+      entry.each_decl do |decl|
+        if align_params = entry.align_params(decl)
+          subst_ = subst + align_params
+        else
+          subst_ = subst
+        end
 
-        d.decl.members.each do |member|
+        decl.members.each do |member|
           case member
           when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
             if member.kind == :instance
@@ -151,6 +154,29 @@ module RBS
               end
             end
 
+          when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+            member.names.each do |name|
+              ivar_name = :"@#{name}"
+              attr_type = member.type || Types::Bases::Any.new(location: nil)
+
+              insert_variable(
+                type_name,
+                definition.instance_variables,
+                name: ivar_name,
+                type: attr_type,
+                source: member
+              )
+            end
+
+          when AST::Ruby::Members::InstanceVariableMember
+            insert_variable(
+              type_name,
+              definition.instance_variables,
+              name: member.name,
+              type: member.type,
+              source: member
+            )
+
           when AST::Members::InstanceVariable
             insert_variable(
               type_name,
@@ -174,7 +200,7 @@ module RBS
 
       try_cache(type_name, cache: instance_cache) do
         entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
-        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
+        ensure_namespace!(type_name.namespace, location: entry.primary_decl.location)
 
         ancestors = ancestor_builder.instance_ancestors(type_name)
         args = entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
@@ -234,7 +260,7 @@ module RBS
     def build_singleton0(type_name)
       try_cache type_name, cache: singleton0_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_singleton0: #{type_name}"
-        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
+        ensure_namespace!(type_name.namespace, location: entry.primary_decl.location)
 
         ancestors = ancestor_builder.singleton_ancestors(type_name)
         self_type = Types::ClassSingleton.new(name: type_name, location: nil)
@@ -272,8 +298,8 @@ module RBS
           interface_methods = interface_methods(all_interfaces)
           import_methods(definition, type_name, methods, interface_methods, Substitution.new, nil)
 
-          entry.decls.each do |d|
-            d.decl.members.each do |member|
+          entry.each_decl do |decl|
+            decl.members.each do |member|
               case member
               when AST::Members::AttrReader, AST::Members::AttrAccessor, AST::Members::AttrWriter
                 if member.kind == :singleton
@@ -306,7 +332,7 @@ module RBS
 
       try_cache type_name, cache: singleton_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
-        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
+        ensure_namespace!(type_name.namespace, location: entry.primary_decl.location)
 
         ancestors = ancestor_builder.singleton_ancestors(type_name)
         self_type = Types::ClassSingleton.new(name: type_name, location: nil)
@@ -375,6 +401,19 @@ module RBS
                         .update(type_params: class_params + method_type.type_params)
                     end
 
+                    method_type = method_type.map_type do |type|
+                      case type
+                      when Types::Bases::Self
+                        Types::ClassInstance.new(
+                          name: type_name,
+                          args: entry.type_params.map {|param| Types::Variable.new(name: param.name, location: param.location) },
+                          location: nil
+                        )
+                      else
+                        type
+                      end
+                    end
+
                     method_type = method_type.update(
                       type: method_type.type.with_return_type(
                         Types::ClassInstance.new(
@@ -452,6 +491,10 @@ module RBS
         case decl
         when AST::Declarations::Class
           decl.super_class&.location
+        when AST::Ruby::Declarations::ClassDecl
+          nil
+        else
+          raise "Unexpected `:super` source location with #{decl.class}"
         end
       else
         source.location
@@ -471,7 +514,7 @@ module RBS
           validate_params_with(type_params, result: result) do |param|
             decl = case entry = definition.entry
                    when Environment::ModuleEntry, Environment::ClassEntry
-                     entry.primary.decl
+                     entry.primary_decl
                    when Environment::SingleEntry
                      entry.decl
                    end
@@ -547,6 +590,7 @@ module RBS
         declared_in: type_name,
         source: source
       )
+
       validate_variable(variables[name])
     end
 
@@ -557,7 +601,15 @@ module RBS
       variables = [] #: Array[Definition::Variable]
       tmp_var = var
       while tmp_var
-        variables << tmp_var if tmp_var.source.is_a?(AST::Members::Var)
+        case tmp_var.source
+        when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+          # nop
+        when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+          # nop
+        else
+          variables << tmp_var
+        end
+
         tmp_var = tmp_var.parent_variable
       end
 
@@ -575,6 +627,10 @@ module RBS
         if r.source.instance_of?(AST::Members::ClassInstanceVariable) && l.declared_in == r.declared_in
           raise ClassInstanceVariableDuplicationError.new(type_name: l.declared_in, variable_name: l.source.name, location: l.source.location)
         end
+      when AST::Ruby::Members::InstanceVariableMember
+        if l.declared_in == r.declared_in
+          raise InstanceVariableDuplicationError.new(type_name: l.declared_in, variable_name: l.source.name, location: l.source.location)
+        end
       end
     end
 
@@ -602,7 +658,7 @@ module RBS
 
         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,
@@ -655,12 +711,14 @@ module RBS
           )
         end
 
+        accessibility = special_accessibility(original.instance?, original.new_name) || original_method.accessibility
+
         method_definition = Definition::Method.new(
           super_method: existing_method,
           defs: original_method.defs.map do |defn|
             defn.update(defined_in: defined_in, implemented_in: implemented_in)
           end,
-          accessibility: original_method.accessibility,
+          accessibility: accessibility,
           alias_of: original_method,
           alias_member: original
         )
@@ -687,13 +745,9 @@ module RBS
           end
         end
 
-        # @type var accessibility: RBS::Definition::accessibility
-        accessibility =
-          if original.instance? && [:initialize, :initialize_copy, :initialize_clone, :initialize_dup, :respond_to_missing?].include?(method.name)
-            :private
-          else
-            method.accessibility
-          end
+        # Respect the visibility of the original method definition.
+        accessibility = original.visibility || special_accessibility(original.instance?, method.name) || method.accessibility
+
         # 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
@@ -746,6 +800,9 @@ module RBS
           super_method = existing_method
         end
 
+        # Respect the visibility of the original method definition.
+        accessibility = original.visibility || special_accessibility(original.kind == :instance, method.name) || method.accessibility
+
         method_definition = Definition::Method.new(
           super_method: super_method,
           defs: [
@@ -756,12 +813,109 @@ module RBS
               implemented_in: implemented_in
             )
           ],
-          accessibility: method.accessibility,
+          accessibility: accessibility,
           alias_of: nil,
           alias_member: nil
         )
 
         method_definition.annotations.replace(original.annotations)
+      when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [*duplicated_method.members, original]
+          )
+        end
+
+        attr_type = original.type || Types::Bases::Any.new(location: nil)
+        method_type =
+          if method.name.to_s.end_with?("=")
+            # setter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type).update(
+                required_positionals: [
+                  Types::Function::Param.new(type: attr_type, name: method.name.to_s.chomp("=").to_sym)
+                ]
+              ),
+              block: nil,
+              location: original.location
+            )
+          else
+            # getter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type),
+              block: nil,
+              location: original.location
+            )
+          end
+
+        if implemented_in
+          super_method = existing_method
+        end
+
+        method_definition = Definition::Method.new(
+          super_method: super_method,
+          defs: [
+            Definition::Method::TypeDef.new(
+              type: method_type,
+              member: original,
+              defined_in: defined_in,
+              implemented_in: implemented_in
+            )
+          ],
+          accessibility: method.accessibility,
+          alias_of: nil,
+          alias_member: nil
+        )
+
+        method_definition.annotations.replace([])
+      when AST::Ruby::Members::DefMember
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [original, *duplicated_method.members]
+          )
+        end
+
+        if original.method_type.empty? && existing_method
+          # Unannotated method with a parent definition → inherit from the parent, like @rbs ...
+          method_definition = Definition::Method.new(
+            super_method: existing_method,
+            defs: existing_method.defs.map { |defn| defn.update(implemented_in: implemented_in) },
+            accessibility: :public,
+            alias_of: existing_method.alias_of,
+            alias_member: nil
+          )
+
+          method_definition.annotations.replace(existing_method.annotations)
+        else
+          defs = original.overloads.map do |overload|
+            Definition::Method::TypeDef.new(
+              type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
+              member: original,
+              defined_in: defined_in,
+              implemented_in: implemented_in
+            ).tap do |type_def|
+              # Keep the original annotations given to overloads.
+              type_def.overload_annotations.replace(overload.annotations)
+            end
+          end
+
+          method_definition = Definition::Method.new(
+            super_method: existing_method,
+            defs: defs,
+            accessibility: :public,
+            alias_of: nil,
+            alias_member: nil
+          )
+
+          method_definition.annotations.replace([])
+        end
+
       when nil
         # Overloading method definition only
 
@@ -819,6 +973,12 @@ module RBS
       methods[method.name] = method_definition
     end
 
+    def special_accessibility(is_instance, method_name)
+      if is_instance && [:initialize, :initialize_copy, :initialize_clone, :initialize_dup, :respond_to_missing?].include?(method_name)
+        :private
+      end
+    end
+
     def try_cache(type_name, cache:)
       cache[type_name] ||= yield
     end

data/lib/rbs/diff.rb

@@ -104,7 +104,13 @@ module RBS
         detail_to_s = @detail ? "[#{definition_method.defined_in} #{definition_method.accessibility}] " : ""
         if definition_method.alias_of
           first_def = definition_method.alias_of.defs.first #: Definition::Method::TypeDef
-          "#{detail_to_s}alias #{prefix}#{key} #{prefix}#{first_def.member.name}"
+          member_name = case first_def.member
+                        when AST::Members::Base
+                          first_def.member.name
+                        else
+                          raise
+                        end
+          "#{detail_to_s}alias #{prefix}#{key} #{prefix}#{member_name}"
         else
           "#{detail_to_s}def #{prefix}#{key}: #{definition_method.method_types.join(" | ")}"
         end

data/lib/rbs/environment/class_entry.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RBS
+  class Environment
+    class ClassEntry
+      attr_reader :name
+
+      attr_reader :context_decls
+
+      def initialize(name)
+        @name = name
+        @context_decls = []
+      end
+
+      def <<(context_decl)
+        context_decls << context_decl
+        @primary_decl = nil
+        self
+      end
+
+      def each_decl(&block)
+        if block
+          context_decls.each do |_, decl|
+            yield decl
+          end
+        else
+          enum_for(__method__ || raise)
+        end
+      end
+
+      def empty?
+        context_decls.empty?
+      end
+
+      def primary_decl
+        @primary_decl ||= nil.tap do
+          # @type break: declaration
+
+          decl = each_decl.find {|decl| decl.super_class }
+          break decl if decl
+
+          decl = each_decl.first
+          break decl if decl
+        end || raise("Cannot find primary declaration for #{name}")
+      end
+
+      def type_params
+        validate_type_params
+        primary_decl.type_params
+      end
+
+      def validate_type_params
+        unless context_decls.empty?
+          first_decl, *rest_decls = each_decl.to_a
+          first_decl or raise
+
+          first_params = first_decl.type_params
+          first_names = first_params.map(&:name)
+          rest_decls.each do |other_decl|
+            other_params = other_decl.type_params
+            unless first_names.size == other_params.size && first_params == AST::TypeParam.rename(other_params, new_names: first_names)
+              raise GenericParameterMismatchError.new(name: name, decl: other_decl)
+            end
+          end
+        end
+      end
+
+      def align_params(decl)
+        entry_params = type_params
+        decl_param_names = decl.type_params.map(&:name)
+
+        return nil if decl_param_names == entry_params.map(&:name)
+
+        Substitution.build(
+          decl_param_names,
+          entry_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
+        )
+      end
+    end
+  end
+end

data/lib/rbs/environment/module_entry.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RBS
+  class Environment
+    class ModuleEntry
+      attr_reader :name
+
+      attr_reader :context_decls
+
+      def initialize(name)
+        @name = name
+        @context_decls = []
+      end
+
+      def <<(context_decl)
+        context_decls << context_decl
+        self
+      end
+
+      def each_decl(&block)
+        if block
+          context_decls.each do |_, decl|
+            yield decl
+          end
+        else
+          enum_for(__method__ || raise)
+        end
+      end
+
+      def empty?
+        context_decls.empty?
+      end
+
+      def primary_decl
+        each_decl.first or raise
+      end
+
+      def type_params
+        validate_type_params
+        primary_decl.type_params
+      end
+
+      def self_types
+        each_decl.flat_map do |decl|
+          self_types = decl.self_types
+          subst = align_params(decl)
+
+          if self_types.empty? || subst.nil?
+            self_types
+          else
+            self_types.map do |self_type|
+              AST::Declarations::Module::Self.new(
+                name: self_type.name,
+                args: self_type.args.map {|type| type.sub(subst) },
+                location: self_type.location
+              )
+            end
+          end
+        end.uniq
+      end
+
+      def align_params(decl)
+        entry_params = type_params
+        decl_param_names = decl.type_params.map(&:name)
+
+        return nil if decl_param_names == entry_params.map(&:name)
+
+        Substitution.build(
+          decl_param_names,
+          entry_params.map {|param| Types::Variable.new(name: param.name, location: param.location) }
+        )
+      end
+
+      def validate_type_params
+        unless context_decls.empty?
+          first_decl, *rest_decls = each_decl.to_a
+          first_decl or raise
+
+          first_params = first_decl.type_params
+          first_names = first_params.map(&:name)
+          rest_decls.each do |other_decl|
+            other_params = other_decl.type_params
+            unless first_names.size == other_params.size && first_params == AST::TypeParam.rename(other_params, new_names: first_names)
+              raise GenericParameterMismatchError.new(name: name, decl: other_decl)
+            end
+          end
+        end
+      end
+    end
+  end
+end