rbs 4.0.0.dev.4 → 4.0.0

data/lib/rbs/definition_builder.rb

@@ -151,6 +151,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,
@@ -375,6 +398,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(
@@ -551,6 +587,7 @@ module RBS
         declared_in: type_name,
         source: source
       )
+
       validate_variable(variables[name])
     end
 
@@ -561,7 +598,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
 
@@ -579,6 +624,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
 
@@ -606,7 +655,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,
@@ -659,12 +708,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
         )
@@ -691,13 +742,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
@@ -750,6 +797,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: [
@@ -760,42 +810,108 @@ 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::DefMember
+      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: [original, *duplicated_method.members]
+            members: [*duplicated_method.members, original]
           )
         end
 
-        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)
+        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: existing_method,
-          defs: defs,
-          accessibility: :public,
+          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
@@ -854,6 +970,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