rbs 2.0.0 → 2.2.2

data/lib/rbs/annotate/rdoc_source.rb

@@ -0,0 +1,120 @@
+module RBS
+  module Annotate
+    class RDocSource
+      attr_accessor :with_system_dir, :with_gems_dir, :with_site_dir, :with_home_dir
+
+      attr_reader :extra_dirs
+
+      attr_reader :stores
+
+      def initialize
+        self.with_system_dir = true
+        self.with_gems_dir = false
+        self.with_site_dir = false
+        self.with_home_dir = false
+
+        @extra_dirs = []
+        @stores = []
+      end
+
+      def load
+        @stores.clear()
+
+        RDoc::RI::Paths.each(with_system_dir, with_site_dir, with_home_dir, with_gems_dir ? :latest : false, *extra_dirs.map(&:to_s)) do |path, type|
+          store = RDoc::Store.new(path, type)
+          store.load_all
+
+          @stores << store
+        end
+      end
+
+      def find_class(typename)
+        classes = []
+
+        @stores.each do |store|
+          if klass = store.find_class_or_module(typename.relative!.to_s)
+            classes << klass
+          end
+        end
+
+        unless classes.empty?
+          classes
+        end
+      end
+
+      def docs
+        if ds = yield
+          unless ds.empty?
+            ds.map(&:comment)
+          end
+        end
+      end
+
+      def class_docs(typename)
+        if classes = find_class(typename)
+          classes.map {|klass| klass.comment }
+        end
+      end
+
+      def find_const(const_name)
+        namespace =
+          if const_name.namespace.empty?
+            TypeName("::Object")
+          else
+            const_name.namespace.to_type_name
+          end
+
+        if classes = find_class(namespace)
+          # @type var consts: Array[RDoc::Constant]
+          consts = []
+
+          classes.each do |klass|
+            if const = klass.constants.find {|c| c.name == const_name.name.to_s }
+              consts << const
+            end
+          end
+
+          unless consts.empty?
+            consts
+          end
+        end
+      end
+
+      def find_method(typename, instance_method: nil, singleton_method: nil)
+        if classes = find_class(typename)
+          # @type var methods: Array[RDoc::AnyMethod]
+          methods = []
+
+          classes.each do |klass|
+            klass.method_list.each do |method|
+              if instance_method && !method.singleton && method.name == instance_method.to_s
+                methods << method
+              end
+
+              if singleton_method && method.singleton && method.name == singleton_method.to_s
+                methods << method
+              end
+            end
+          end
+
+          unless methods.empty?
+            methods
+          end
+        end
+      end
+
+      def find_attribute(typename, name, singleton:)
+        if klasss = find_class(typename)
+          # @type var attrs: Array[RDoc::Attr]
+          attrs = []
+
+          klasss.each do |kls|
+            attrs.concat(kls.attributes.select {|attr| attr.singleton == singleton && attr.name == name.to_s })
+          end
+
+          attrs unless attrs.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rbs/annotate.rb

@@ -0,0 +1,6 @@
+require "rdoc"
+
+require "rbs/annotate/rdoc_annotator"
+require "rbs/annotate/rdoc_source"
+require "rbs/annotate/annotations"
+require "rbs/annotate/formatter"

data/lib/rbs/ast/members.rb

@@ -12,8 +12,9 @@ module RBS
         attr_reader :location
         attr_reader :comment
         attr_reader :overload
+        attr_reader :visibility
 
-        def initialize(name:, kind:, types:, annotations:, location:, comment:, overload:)
+        def initialize(name:, kind:, types:, annotations:, location:, comment:, overload:, visibility: nil)
           @name = name
           @kind = kind
           @types = types
@@ -21,6 +22,7 @@ module RBS
           @location = location
           @comment = comment
           @overload = overload ? true : false
+          @visibility = visibility
         end
 
         def ==(other)
@@ -28,13 +30,14 @@ module RBS
             other.name == name &&
             other.kind == kind &&
             other.types == types &&
-            other.overload == overload
+            other.overload == overload &&
+            other.visibility == visibility
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ kind.hash ^ types.hash ^ overload.hash
+          name.hash ^ kind.hash ^ types.hash ^ overload.hash
         end
 
         def instance?
@@ -49,7 +52,7 @@ module RBS
           overload
         end
 
-        def update(name: self.name, kind: self.kind, types: self.types, annotations: self.annotations, location: self.location, comment: self.comment, overload: self.overload)
+        def update(name: self.name, kind: self.kind, types: self.types, annotations: self.annotations, location: self.location, comment: self.comment, overload: self.overload, visibility: self.visibility)
           self.class.new(
             name: name,
             kind: kind,
@@ -57,7 +60,8 @@ module RBS
             annotations: annotations,
             location: location,
             comment: comment,
-            overload: overload
+            overload: overload,
+            visibility: visibility
           )
         end
 
@@ -94,7 +98,7 @@ module RBS
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type.hash
+          name.hash ^ type.hash
         end
       end
 
@@ -164,7 +168,7 @@ module RBS
         end
 
         def hash
-          self.class.hash ^ name.hash ^ args.hash
+          name.hash ^ args.hash
         end
       end
 
@@ -221,8 +225,9 @@ module RBS
         attr_reader :annotations
         attr_reader :location
         attr_reader :comment
+        attr_reader :visibility
 
-        def initialize(name:, type:, ivar_name:, kind:, annotations:, location:, comment:)
+        def initialize(name:, type:, ivar_name:, kind:, annotations:, location:, comment:, visibility: nil)
           @name = name
           @type = type
           @ivar_name = ivar_name
@@ -230,6 +235,7 @@ module RBS
           @location = location
           @comment = comment
           @kind = kind
+          @visibility = visibility
         end
 
         def ==(other)
@@ -237,16 +243,17 @@ module RBS
             other.name == name &&
             other.type == type &&
             other.ivar_name == ivar_name &&
-            other.kind == kind
+            other.kind == kind &&
+            other.visibility == visibility
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type.hash ^ ivar_name.hash ^ kind.hash
+          name.hash ^ type.hash ^ ivar_name.hash ^ kind.hash ^ visibility.hash
         end
 
-        def update(name: self.name, type: self.type, ivar_name: self.ivar_name, kind: self.kind, annotations: self.annotations, location: self.location, comment: self.comment)
+        def update(name: self.name, type: self.type, ivar_name: self.ivar_name, kind: self.kind, annotations: self.annotations, location: self.location, comment: self.comment, visibility: self.visibility)
           klass = _ = self.class
           klass.new(
             name: name,
@@ -255,7 +262,8 @@ module RBS
             kind: kind,
             annotations: annotations,
             location: location,
-            comment: comment
+            comment: comment,
+            visibility: visibility
           )
         end
       end
@@ -372,7 +380,7 @@ module RBS
         alias eql? ==
 
         def hash
-          self.class.hash ^ new_name.hash ^ old_name.hash ^ kind.hash
+          new_name.hash ^ old_name.hash ^ kind.hash
         end
 
         def to_json(state = _ = nil)

data/lib/rbs/buffer.rb

@@ -2,23 +2,29 @@ module RBS
   class Buffer
     attr_reader :name
     attr_reader :content
-    attr_reader :lines
-    attr_reader :ranges
 
     def initialize(name:, content:)
       @name = name
       @content = content
+    end
 
-      @lines = content.lines
+    def lines
+      @lines ||= content.lines
+    end
 
-      @ranges = []
-      offset = 0
-      lines.each do |line|
-        size = line.size
-        range = offset...(offset+size)
-        ranges << range
-        offset += size
-      end
+    def ranges
+      @ranges ||=
+        begin
+          @ranges = []
+          offset = 0
+          lines.each do |line|
+            size = line.size
+            range = offset...(offset+size)
+            @ranges << range
+            offset += size
+          end
+          @ranges
+        end
     end
 
     def pos_to_loc(pos)

data/lib/rbs/cli.rb

@@ -80,7 +80,7 @@ module RBS
       @stderr = stderr
     end
 
-    COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test, :collection]
+    COMMANDS = [:ast, :annotate, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test, :collection]
 
     def parse_logging_options(opts)
       opts.on("--log-level LEVEL", "Specify log level (defaults to `warn`)") do |level|
@@ -791,6 +791,53 @@ Examples:
       exit 1 if syntax_error
     end
 
+    def run_annotate(args, options)
+      require "rbs/annotate"
+
+      source = RBS::Annotate::RDocSource.new()
+      annotator = RBS::Annotate::RDocAnnotator.new(source: source)
+
+      preserve = true
+
+      OptionParser.new do |opts|
+        opts.banner = <<-EOB
+Usage: rbs annotate [options...] [files...]
+
+Import documents from RDoc and update RBS files.
+
+Examples:
+
+  $ rbs annotate stdlib/pathname/**/*.rbs
+
+Options:
+        EOB
+
+        opts.on("--[no-]system", "Load RDoc from system (defaults to true)") {|b| source.with_system_dir = b }
+        opts.on("--[no-]gems", "Load RDoc from gems (defaults to false)") {|b| source.with_gems_dir = b }
+        opts.on("--[no-]site", "Load RDoc from site directory (defaults to false)") {|b| source.with_site_dir = b }
+        opts.on("--[no-]home", "Load RDoc from home directory (defaults to false)") {|b| source.with_home_dir = b }
+        opts.on("-d", "--dir DIRNAME", "Load RDoc from DIRNAME") {|d| source.extra_dirs << Pathname(d) }
+        opts.on("--[no-]arglists", "Generate arglists section (defaults to true)") {|b| annotator.include_arg_lists = b }
+        opts.on("--[no-]filename", "Include source file name in the documentation (defaults to true)") {|b| annotator.include_filename = b }
+        opts.on("--[no-]preserve", "Try preserve the format of the original file (defaults to true)") {|b| preserve = b }
+      end.parse!(args)
+
+      source.load()
+
+      args.each do |file|
+        path = Pathname(file)
+        if path.directory?
+          Pathname.glob((path + "**/*.rbs").to_s).each do |path|
+            stdout.puts "Processing #{path}..."
+            annotator.annotate_file(path, preserve: preserve)
+          end
+        else
+          stdout.puts "Processing #{path}..."
+          annotator.annotate_file(path, preserve: preserve)
+        end
+      end
+    end
+
     def test_opt options
       opts = []
 

data/lib/rbs/definition_builder/method_builder.rb

@@ -10,7 +10,11 @@ module RBS
           end
 
           def accessibility
-            accessibilities[0]
+            if original.is_a?(AST::Members::Alias)
+              raise "alias member doesn't have accessibility"
+            else
+              accessibilities[0] or raise
+            end
           end
 
           def self.empty(name:, type:)
@@ -102,22 +106,32 @@ module RBS
                 each_member_with_accessibility(d.decl.members) do |member, accessibility|
                   case member
                   when AST::Members::MethodDefinition
-                    if member.instance?
-                      build_method(methods,
-                                   type,
-                                   member: member.update(types: member.types.map {|type| type.sub(subst) }),
-                                   accessibility: accessibility)
+                    case member.kind
+                    when :instance
+                      build_method(
+                        methods,
+                        type,
+                        member: member.update(types: member.types.map {|type| type.sub(subst) }),
+                        accessibility: member.visibility || accessibility
+                      )
+                    when :singleton_instance
+                      build_method(
+                        methods,
+                        type,
+                        member: member.update(types: member.types.map {|type| type.sub(subst) }),
+                        accessibility: :private
+                      )
                     end
                   when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
                     if member.kind == :instance
                       build_attribute(methods,
                                       type,
                                       member: member.update(type: member.type.sub(subst)),
-                                      accessibility: accessibility)
+                                      accessibility: member.visibility || accessibility)
                     end
                   when AST::Members::Alias
                     if member.kind == :instance
-                      build_alias(methods, type, member: member, accessibility: accessibility)
+                      build_alias(methods, type, member: member)
                     end
                   end
                 end
@@ -134,19 +148,19 @@ module RBS
 
             Methods.new(type: type).tap do |methods|
               entry.decls.each do |d|
-                each_member_with_accessibility(d.decl.members) do |member, accessibility|
+                d.decl.members.each do |member|
                   case member
                   when AST::Members::MethodDefinition
                     if member.singleton?
-                      build_method(methods, type, member: member, accessibility: accessibility)
+                      build_method(methods, type, member: member, accessibility: member.visibility || :public)
                     end
                   when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
                     if member.kind == :singleton
-                      build_attribute(methods, type, member: member, accessibility: accessibility)
+                      build_attribute(methods, type, member: member, accessibility: member.visibility || :public)
                     end
                   when AST::Members::Alias
                     if member.kind == :singleton
-                      build_alias(methods, type, member: member, accessibility: accessibility)
+                      build_alias(methods, type, member: member)
                     end
                   end
                 end
@@ -168,18 +182,16 @@ module RBS
                 when AST::Members::MethodDefinition
                   build_method(methods, type, member: member, accessibility: :public)
                 when AST::Members::Alias
-                  build_alias(methods, type, member: member, accessibility: :public)
+                  build_alias(methods, type, member: member)
                 end
               end
             end.validate!
           end
       end
 
-      def build_alias(methods, type, member:, accessibility:)
+      def build_alias(methods, type, member:)
         defn = methods.methods[member.new_name] ||= Methods::Definition.empty(type: type, name: member.new_name)
-
         defn.originals << member
-        defn.accessibilities << accessibility
       end
 
       def build_attribute(methods, type, member:, accessibility:)

data/lib/rbs/definition_builder.rb

@@ -539,8 +539,12 @@ module RBS
 
         if method_types
           method_types.each do |method_type|
+            merged_params = type_params
+              .reject {|param| method_type.type_param_names.include?(param.name) }
+              .concat(method_type.type_params)
+
             result = calculator.in_method_type(method_type: method_type, variables: param_names)
-            validate_params_with(type_params, result: result) do |param|
+            validate_params_with(merged_params, result: result) do |param|
               raise InvalidVarianceAnnotationError.new(
                 type_name: definition.type_name,
                 param: param,
@@ -583,7 +587,7 @@ module RBS
             defs: original_method.defs.map do |defn|
               defn.update(defined_in: definition.type_name, implemented_in: definition.type_name)
             end,
-            accessibility: method_def.accessibility,
+            accessibility: original_method.accessibility,
             alias_of: original_method
           )
         else

data/lib/rbs/environment.rb

@@ -357,7 +357,8 @@ module RBS
           comment: member.comment,
           overload: member.overload?,
           annotations: member.annotations,
-          location: member.location
+          location: member.location,
+          visibility: member.visibility
         )
       when AST::Members::AttrAccessor
         AST::Members::AttrAccessor.new(
@@ -367,7 +368,8 @@ module RBS
           annotations: member.annotations,
           comment: member.comment,
           location: member.location,
-          ivar_name: member.ivar_name
+          ivar_name: member.ivar_name,
+          visibility: member.visibility
         )
       when AST::Members::AttrReader
         AST::Members::AttrReader.new(
@@ -377,7 +379,8 @@ module RBS
           annotations: member.annotations,
           comment: member.comment,
           location: member.location,
-          ivar_name: member.ivar_name
+          ivar_name: member.ivar_name,
+          visibility: member.visibility
         )
       when AST::Members::AttrWriter
         AST::Members::AttrWriter.new(
@@ -387,7 +390,8 @@ module RBS
           annotations: member.annotations,
           comment: member.comment,
           location: member.location,
-          ivar_name: member.ivar_name
+          ivar_name: member.ivar_name,
+          visibility: member.visibility
         )
       when AST::Members::InstanceVariable
         AST::Members::InstanceVariable.new(

data/lib/rbs/location_aux.rb

@@ -119,5 +119,17 @@ module RBS
         enum_for(:each_required_key)
       end
     end
+
+    def key?(name)
+      optional_key?(name) || required_key?(name)
+    end
+
+    def optional_key?(name)
+      _optional_keys.include?(name)
+    end
+
+    def required_key?(name)
+      _required_keys.include?(name)
+    end
   end
 end

data/lib/rbs/namespace.rb

@@ -59,7 +59,7 @@ module RBS
     alias eql? ==
 
     def hash
-      self.class.hash ^ path.hash ^ absolute?.hash
+      path.hash ^ absolute?.hash
     end
 
     def split

data/lib/rbs/prototype/rb.rb

@@ -197,6 +197,18 @@ module RBS
                 )
               end
             end
+          when :prepend
+            args.each do |arg|
+              if (name = const_to_name(arg))
+                decls << AST::Members::Prepend.new(
+                  name: name,
+                  args: [],
+                  annotations: [],
+                  location: nil,
+                  comment: comments[node.first_lineno - 1]
+                )
+              end
+            end
           when :extend
             args.each do |arg|
               if (name = const_to_name(arg, context: context))

data/lib/rbs/type_alias_regularity.rb

@@ -55,7 +55,7 @@ module RBS
     end
 
     def build_alias_type(name)
-      entry = env.alias_decls[name] or raise "Unknown alias name: #{name}"
+      entry = env.alias_decls[name] or return
       unless entry.decl.type_params.empty?
         as = entry.decl.type_params.each.map {|param| Types::Variable.new(name: param.name, location: nil) }
         Types::Alias.new(name: name, args: as, location: nil)
@@ -85,9 +85,11 @@ module RBS
       end
       # @type var each_child: TSort::_EachChild[TypeName]
       each_child = __skip__ = -> (name, &block) do
-        type = builder.expand_alias1(name)
-        each_alias_type(type) do |ty|
-          block[ty.name]
+        if env.alias_decls.key?(name)
+          type = builder.expand_alias1(name)
+          each_alias_type(type) do |ty|
+            block[ty.name]
+          end
         end
       end
 

data/lib/rbs/type_name.rb

@@ -27,7 +27,7 @@ module RBS
     alias eql? ==
 
     def hash
-      self.class.hash ^ namespace.hash ^ name.hash
+      namespace.hash ^ name.hash
     end
 
     def to_s

data/lib/rbs/types.rb

@@ -213,7 +213,7 @@ module RBS
       alias eql? ==
 
       def hash
-        self.class.hash ^ name.hash ^ args.hash
+        name.hash ^ args.hash
       end
 
       def free_variables(set = Set.new)

data/lib/rbs/validator.rb

@@ -73,6 +73,8 @@ module RBS
         if set = result.incompatible?(entry.decl.type_params)
           set.each do |param_name|
             param = entry.decl.type_params.find {|param| param.name == param_name } or raise
+            next if param.unchecked?
+
             raise InvalidVarianceAnnotationError.new(
               type_name: type_name,
               param: param,
@@ -87,6 +89,10 @@ module RBS
           location: entry.decl.location&.aref(:type_params)
         )
       end
+
+      if block_given?
+        yield entry.decl.type
+      end
     end
 
     def validate_method_definition(method_def, type_name:)

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "2.0.0"
+  VERSION = "2.2.2"
 end