rbs-relaxed 3.9.0.1 → 3.9.4.0

data/lib/rbs/definition_builder.rb

@@ -82,7 +82,7 @@ module RBS
       AST::TypeParam.application(params, args) || Substitution.new()
     end
 
-    def define_instance(definition, type_name, subst)
+    def define_instance(definition, type_name, subst, define_class_vars:)
       one_ancestors = ancestor_builder.one_instance_ancestors(type_name)
       methods = method_builder.build_instance(type_name)
 
@@ -104,7 +104,7 @@ module RBS
           validate_type_presence(arg)
         end
 
-        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args))
+        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args), define_class_vars: define_class_vars)
       end
 
       all_interfaces = one_ancestors.each_included_interface.flat_map do |interface|
@@ -120,7 +120,7 @@ module RBS
           validate_type_presence(arg)
         end
 
-        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args))
+        define_instance(definition, mod.name, subst + tapp_subst(mod.name, mod.args), define_class_vars: define_class_vars)
       end
 
       entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
@@ -145,23 +145,25 @@ module RBS
                   type_name,
                   definition.instance_variables,
                   name: ivar_name,
-                  type: member.type.sub(subst_)
+                  type: member.type.sub(subst_),
+                  source: member
                 )
               end
             end
 
           when AST::Members::InstanceVariable
-            InstanceVariableDuplicationError.check!(variables: definition.instance_variables, member: member, type_name: type_name)
             insert_variable(
               type_name,
               definition.instance_variables,
               name: member.name,
-              type: member.type.sub(subst_)
+              type: member.type.sub(subst_),
+              source: member
             )
 
           when AST::Members::ClassVariable
-            ClassVariableDuplicationError.check!(variables: definition.class_variables, member: member, type_name: type_name)
-            insert_variable(type_name, definition.class_variables, name: member.name, type: member.type)
+            if define_class_vars
+              insert_variable(type_name, definition.class_variables, name: member.name, type: member.type, source: member)
+            end
           end
         end
       end
@@ -216,13 +218,13 @@ module RBS
                 if ans.name.interface?
                   define_interface(definition, ans.name, subst)
                 else
-                  define_instance(definition, ans.name, subst)
+                  define_instance(definition, ans.name, subst, define_class_vars: true)
                 end
               end
             end
           end
 
-          define_instance(definition, type_name, Substitution.new)
+          define_instance(definition, type_name, Substitution.new, define_class_vars: true)
         end
       end
     end
@@ -251,7 +253,6 @@ module RBS
 
             definition.methods.merge!(defn.methods)
             definition.instance_variables.merge!(defn.instance_variables)
-            definition.class_variables.merge!(defn.class_variables)
           end
 
           one_ancestors.each_extended_module do |mod|
@@ -260,7 +261,7 @@ module RBS
             end
 
             subst = tapp_subst(mod.name, mod.args)
-            define_instance(definition, mod.name, subst)
+            define_instance(definition, mod.name, subst, define_class_vars: false)
           end
 
           all_interfaces = one_ancestors.each_extended_interface.flat_map do |interface|
@@ -284,20 +285,18 @@ module RBS
                               end
 
                   if ivar_name
-                    insert_variable(type_name, definition.instance_variables, name: ivar_name, type: member.type)
+                    insert_variable(type_name, definition.instance_variables, name: ivar_name, type: member.type, source: member)
                   end
                 end
 
               when AST::Members::ClassInstanceVariable
-                ClassInstanceVariableDuplicationError.check!(variables: definition.instance_variables, member: member, type_name: type_name)
-                insert_variable(type_name, definition.instance_variables, name: member.name, type: member.type)
-
-              when AST::Members::ClassVariable
-                ClassVariableDuplicationError.check!(variables: definition.class_variables, member: member, type_name: type_name)
-                insert_variable(type_name, definition.class_variables, name: member.name, type: member.type)
+                insert_variable(type_name, definition.instance_variables, name: member.name, type: member.type, source: member)
               end
             end
           end
+
+          instance_definition = build_instance(type_name)
+          definition.class_variables.replace(instance_definition.class_variables)
         end
       end
     end
@@ -390,12 +389,14 @@ module RBS
                       type: method_type,
                       member: initialize_def.member,
                       defined_in: initialize_def.defined_in,
-                      implemented_in: initialize_def.implemented_in,
-                      overload_annotations: initialize_def.overload_annotations
-                    )
+                      implemented_in: initialize_def.implemented_in
+                    ).tap do |type_def|
+                      type_def.overload_annotations.replace(initialize_def.overload_annotations)
+                    end
                   end,
                   accessibility: :public,
-                  alias_of: nil
+                  alias_of: nil,
+                  alias_member: nil
                 )
 
                 definition.methods[:new] = typed_new
@@ -539,12 +540,42 @@ module RBS
       end
     end
 
-    def insert_variable(type_name, variables, name:, type:)
+    def insert_variable(type_name, variables, name:, type:, source:)
       variables[name] = Definition::Variable.new(
         parent_variable: variables[name],
         type: type,
-        declared_in: type_name
+        declared_in: type_name,
+        source: source
       )
+      validate_variable(variables[name])
+    end
+
+    def validate_variable(var)
+      return unless var.parent_variable
+
+      # Ignore attrs
+      variables = [] #: Array[Definition::Variable]
+      tmp_var = var
+      while tmp_var
+        variables << tmp_var if tmp_var.source.is_a?(AST::Members::Var)
+        tmp_var = tmp_var.parent_variable
+      end
+
+      # Duplicates should be eliminated, so there can't be more than 3.
+      return unless variables.length == 2
+
+      l, r = variables #: [Definition::Variable, Definition::Variable]
+
+      case l.source
+      when AST::Members::InstanceVariable
+        if r.source.instance_of?(AST::Members::InstanceVariable) && l.declared_in == r.declared_in
+          raise InstanceVariableDuplicationError.new(type_name: l.declared_in, variable_name: l.source.name, location: l.source.location)
+        end
+      when AST::Members::ClassInstanceVariable
+        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
+      end
     end
 
     def import_methods(definition, module_name, module_methods, interfaces_methods, subst, self_type_methods)
@@ -630,8 +661,11 @@ module RBS
             defn.update(defined_in: defined_in, implemented_in: implemented_in)
           end,
           accessibility: original_method.accessibility,
-          alias_of: original_method
+          alias_of: original_method,
+          alias_member: original
         )
+
+        method_definition.annotations.replace(original.annotations)
       when AST::Members::MethodDefinition
         if duplicated_method = methods[method.name]
           raise DuplicatedMethodDefinitionError.new(
@@ -646,9 +680,11 @@ module RBS
             type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
             member: original,
             defined_in: defined_in,
-            implemented_in: implemented_in,
-            overload_annotations: overload.annotations
-          )
+            implemented_in: implemented_in
+          ).tap do |type_def|
+            # Keep the original annotations given to overloads.
+            type_def.overload_annotations.replace(overload.annotations)
+          end
         end
 
         # @type var accessibility: RBS::Definition::accessibility
@@ -668,8 +704,11 @@ module RBS
           super_method: super_method,
           defs: defs,
           accessibility: accessibility,
-          alias_of: nil
+          alias_of: nil,
+          alias_member: nil
         )
+
+        method_definition.annotations.replace(original.annotations)
       when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
         if duplicated_method = methods[method.name]
           raise DuplicatedMethodDefinitionError.new(
@@ -718,8 +757,11 @@ module RBS
             )
           ],
           accessibility: method.accessibility,
-          alias_of: nil
+          alias_of: nil,
+          alias_member: nil
         )
+
+        method_definition.annotations.replace(original.annotations)
       when nil
         # Overloading method definition only
 
@@ -746,8 +788,11 @@ module RBS
             defn.update(implemented_in: implemented_in)
           end,
           accessibility: existing_method.accessibility,
-          alias_of: existing_method.alias_of
+          alias_of: existing_method.alias_of,
+          alias_member: nil
         )
+
+        method_definition.annotations.replace(existing_method.annotations)
       end
 
       method.overloads.each do |overloading_def|
@@ -756,12 +801,19 @@ module RBS
             type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
             member: overloading_def,
             defined_in: defined_in,
-            implemented_in: implemented_in,
-            overload_annotations: overload.annotations
+            implemented_in: implemented_in
           )
 
+          type_def.overload_annotations.replace(overload.annotations)
+
           method_definition.defs.unshift(type_def)
         end
+
+        method_definition.annotations.concat(overloading_def.annotations)
+      end
+
+      method_definition.defs.each do |type_def|
+        type_def.member_annotations.replace(method_definition.annotations)
       end
 
       methods[method.name] = method_definition

data/lib/rbs/environment.rb

@@ -552,7 +552,8 @@ module RBS
           name: decl.name,
           type: absolute_type(resolver, map, decl.type, context: nil),
           location: decl.location,
-          comment: decl.comment
+          comment: decl.comment,
+          annotations: decl.annotations
         )
       end
 
@@ -660,7 +661,8 @@ module RBS
           name: decl.name.with_prefix(prefix),
           type: absolute_type(resolver, map, decl.type, context: context),
           location: decl.location,
-          comment: decl.comment
+          comment: decl.comment,
+          annotations: decl.annotations
         )
 
       when AST::Declarations::ClassAlias
@@ -668,7 +670,8 @@ module RBS
           new_name: decl.new_name.with_prefix(prefix),
           old_name: absolute_type_name(resolver, map, decl.old_name, context: context),
           location: decl.location,
-          comment: decl.comment
+          comment: decl.comment,
+          annotations: decl.annotations
         )
 
       when AST::Declarations::ModuleAlias
@@ -676,7 +679,8 @@ module RBS
           new_name: decl.new_name.with_prefix(prefix),
           old_name: absolute_type_name(resolver, map, decl.old_name, context: context),
           location: decl.location,
-          comment: decl.comment
+          comment: decl.comment,
+          annotations: decl.annotations
         )
       end
     end

data/lib/rbs/errors.rb

@@ -325,46 +325,25 @@ module RBS
   class VariableDuplicationError < DefinitionError
     include DetailedMessageable
 
-    attr_reader :member
-
-    def initialize(member:)
-      @member = member
+    attr_reader :type_name
+    attr_reader :variable_name
+    attr_reader :location
 
-      super "#{Location.to_string location}: Duplicated variable name #{member.name}"
-    end
+    def initialize(type_name:, variable_name:, location:)
+      @type_name = type_name
+      @variable_name = variable_name
+      @location = location
 
-    def location
-      loc = @member.location or raise
-      loc[:name]
+      super "#{Location.to_string location}: Duplicated #{kind} variable name `#{variable_name}` in `#{type_name}`"
     end
   end
 
   class InstanceVariableDuplicationError < VariableDuplicationError
-    def self.check!(variables:, member:, type_name:)
-      if old = variables[member.name]
-        if old.declared_in == type_name
-          raise new(member: member)
-        end
-      end
-    end
+    def kind = 'instance'
   end
 
   class ClassInstanceVariableDuplicationError < VariableDuplicationError
-    def self.check!(variables:, member:, type_name:)
-      if old = variables[member.name]
-        if old.declared_in == type_name
-          raise new(member: member)
-        end
-      end
-    end
-  end
-
-  class ClassVariableDuplicationError < VariableDuplicationError
-    def self.check!(variables:, member:, type_name:)
-      if old = variables[member.name]
-        raise new(member: member)
-      end
-    end
+    def kind = 'class instance'
   end
 
   class UnknownMethodAliasError < DefinitionError

data/lib/rbs/prototype/rb.rb

@@ -382,7 +382,8 @@ module RBS
             name: const_name,
             type: type,
             location: nil,
-            comment: comments[node.first_lineno - 1]
+            comment: comments[node.first_lineno - 1],
+            annotations: []
           )
 
         when :IASGN

data/lib/rbs/prototype/rbi.rb

@@ -257,7 +257,8 @@ module RBS
               name: name,
               type: type,
               location: nil,
-              comment: nil
+              comment: nil,
+              annotations: []
             )
           end
         when :ALIAS

data/lib/rbs/prototype/runtime.rb

@@ -250,6 +250,8 @@ module RBS
               method = builder.build_singleton(module_name.absolute!).methods[singleton]
               method_name = singleton
               kind = :singleton
+            else
+              raise
             end
 
             if method
@@ -462,6 +464,7 @@ module RBS
             name: to_type_name(name.to_s),
             type: type,
             location: nil,
+            annotations: [],
             comment: nil
           )
         end

data/lib/rbs/types.rb

@@ -109,18 +109,14 @@ module RBS
       class Any < Base
         def initialize(location:, todo: false)
           super(location: location)
-          todo! if todo
+          if todo
+            @string = "__todo__"
+          end
         end
 
         def to_s(level=0)
           @string || "untyped"
         end
-
-        # @deprecated: this method is now called from the constructor, do not call it from outside
-        def todo!
-          @string = '__todo__'
-          self
-        end
       end
       class Nil < Base; end
       class Top < Base; end

data/lib/rbs/unit_test/type_assertions.rb

@@ -183,7 +183,7 @@ module RBS
           assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
 
           method_defs = method_defs(method)
-          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.annotations) }
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
           assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
 
           raise exception if exception
@@ -220,7 +220,7 @@ module RBS
           assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }
 
           method_defs = method_defs(method)
-          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.annotations) }
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
           assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
 
           result

data/lib/rbs/unit_test/with_aliases.rb

@@ -127,7 +127,9 @@ module RBS
 
             # `Range` requires `begin <=> end` to return non-nil, but doesn't actually
             # end up using the return value of it. This is to add that in when needed.
-            def lower.<=>(rhs) = :not_nil unless defined? lower.<=>
+            unless defined? lower.<=>
+              def lower.<=>(rhs) = :not_nil # steep:ignore MethodDefinitionInUndeclaredModule
+            end
 
             # If `lower <=> rhs` is defined but nil, then that means we're going to be constructing
             # an illegal range (eg `3..ToInt.new(4)`). So, we need to skip yielding an invalid range

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.9.0.1"
+  VERSION = "3.9.4.0"
 end

data/sig/annotate/rdoc_source.rbs

@@ -25,6 +25,8 @@ module RBS
                      | (TypeName, singleton_method: Symbol) -> Array[RDoc::AnyMethod]?
 
       def find_attribute: (TypeName, Symbol, singleton: bool) -> Array[RDoc::Attr]?
+
+      def class_docs: (TypeName) -> Array[::RDoc::Markup::Document | ::RDoc::Comment | ::String]?
     end
   end
 end

data/sig/cli.rbs

@@ -80,6 +80,8 @@ module RBS
 
     def run_subtract: (Array[String], top) -> void
 
+    def run_diff: (Array[String], LibraryOptions) -> void
+
     def test_opt: (LibraryOptions) -> String?
 
     def collection_options: (Array[String]) -> OptionParser

data/sig/collection/config/lockfile_generator.rbs

@@ -4,7 +4,7 @@ module RBS
       class LockfileGenerator
         # Name of stdlibs that was rbs-bundled stdlib but is now a gem.
         #
-        ALUMNI_STDLIBS: Hash[String, String]
+        ALUMNI_STDLIBS: Hash[String, String?]
 
         class GemfileLockMismatchError < StandardError
           @expected: Pathname

data/sig/declarations.rbs

@@ -205,8 +205,10 @@ module RBS
         attr_reader type: Types::t
         attr_reader location: loc?
         attr_reader comment: Comment?
+        attr_reader annotations: Array[Annotation]
 
-        def initialize: (name: TypeName, type: Types::t, location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type: Types::t, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (name: TypeName, type: Types::t, location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -223,8 +225,10 @@ module RBS
         attr_reader type: Types::t
         attr_reader location: loc?
         attr_reader comment: Comment?
+        attr_reader annotations: Array[Annotation]
 
-        def initialize: (name: Symbol, type: Types::t, location: loc?, comment: Comment?) -> void
+        def initialize: (name: Symbol, type: Types::t, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (name: Symbol, type: Types::t, location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -250,7 +254,10 @@ module RBS
 
         attr_reader comment: Comment?
 
-        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
+        attr_reader annotations: Array[Annotation]
+
+        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
 
         include _HashEqual
       end

data/sig/definition.rbs

@@ -6,8 +6,15 @@ module RBS
       attr_reader parent_variable: Variable?
       attr_reader type: Types::t
       attr_reader declared_in: TypeName
+      type source = AST::Members::AttrAccessor
+                  | AST::Members::AttrReader
+                  | AST::Members::AttrWriter
+                  | AST::Members::InstanceVariable
+                  | AST::Members::ClassVariable
+                  | AST::Members::ClassInstanceVariable
+      attr_reader source: source
 
-      def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName) -> void
+      def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName, source: source) -> void
 
       def sub: (Substitution) -> Variable
     end
@@ -21,22 +28,50 @@ module RBS
         attr_reader defined_in: TypeName
         attr_reader implemented_in: TypeName?
 
-        # Annotations given to `#member`
+        # Annotations given to the method definition syntax
+        #
+        # If the method have multiple syntaxes, union of the annotations to the member will be included, without dedup.
+        #
+        # The value should be updated during setup.
+        #
         attr_reader member_annotations: Array[AST::Annotation]
 
         # Annotations given to the overload associated to the method type
+        #
+        # The value should be updated during setup.
+        #
         attr_reader overload_annotations: Array[AST::Annotation]
 
-        # Concatenation of `member_annotations` and `overload_annotations`
-        attr_reader annotations: Array[AST::Annotation]
-
-        def initialize: (type: MethodType, member: method_member, defined_in: TypeName, implemented_in: TypeName?, ?overload_annotations: Array[AST::Annotation]) -> void
+        # Always returns an empty array
+        %a{deprecated} attr_reader annotations: Array[AST::Annotation]
+
+        # `overload_annotations` is ignored.
+        def initialize: (
+            type: MethodType,
+            member: method_member,
+            defined_in: TypeName,
+            implemented_in: TypeName?
+          ) -> void
+        | %a{deprecated} (
+            type: MethodType,
+            member: method_member,
+            defined_in: TypeName,
+            implemented_in: TypeName?,
+            overload_annotations: nil
+          ) -> void
 
         def comment: () -> AST::Comment?
 
         def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName, ?implemented_in: TypeName?) -> TypeDef
 
         def overload?: () -> bool
+
+        # Yields member and overload annotations, without dedup
+        #
+        # Member annotation yields first.
+        #
+        def each_annotation: () { (AST::Annotation) -> void } -> void
+                           | () -> Enumerator[AST::Annotation]
       end
 
       attr_reader super_method: Method?
@@ -49,21 +84,38 @@ module RBS
       attr_reader comments: Array[AST::Comment]
 
       attr_reader members: Array[method_member]
+
+      # The original method when the method is defined with `alias` syntax
       attr_reader alias_of: Method?
 
+      # Present if the method is defined with `alias` syntax
+      attr_reader alias_member: AST::Members::Alias?
+
       # Unused, always returns empty array
-      attr_reader extra_annotations: Array[AST::Annotation]
+      %a{deprecated} attr_reader extra_annotations: Array[AST::Annotation]
 
-      # Union of annotations given to `defs`, not contains annotations given to each overload
+      # Union of annotations given to `def`s and `alias`, not contains annotations given to each overload
+      #
+      # The elements will be updated during `Method` object setup.
+      #
       attr_reader annotations: Array[AST::Annotation]
 
       # Note that the annotations given through `annotations:` keyword is ignored.
       #
-      def initialize: (super_method: Method?,
-                       defs: Array[TypeDef],
-                       accessibility: accessibility,
-                       alias_of: Method?,
-                       ?annotations: Array[AST::Annotation]) -> void
+      def initialize: (
+          super_method: Method?,
+          defs: Array[TypeDef],
+          accessibility: accessibility,
+          alias_of: Method?,
+          alias_member: AST::Members::Alias?
+        ) -> void
+      | %a{deprecated} (
+          super_method: Method?,
+          defs: Array[TypeDef],
+          accessibility: accessibility,
+          alias_of: Method?,
+          annotations: Array[AST::Annotation]
+        ) -> void
 
       def public?: () -> bool
 
@@ -90,7 +142,8 @@ module RBS
         ?defs: Array[TypeDef],
         ?accessibility: accessibility,
         ?alias_of: Method?,
-        ?annotations: Array[AST::Annotation]
+        ?annotations: Array[AST::Annotation],
+        ?alias_member: AST::Members::Alias?
       ) -> Method
     end