Add annotations for empty collections

Author: soutaro

lib/rbs/annotate/rdoc_source.rb

@@ -31,7 +31,7 @@ def load
       end
 
       def find_class(typename)
-        classes = []
+        classes = [] #: Array[::RDoc::ClassModule]
 
         @stores.each do |store|
           if klass = store.find_class_or_module(typename.relative!.to_s)

lib/rbs/cli.rb

@@ -554,11 +554,11 @@ def run_prototype(args, options)
       when "rbi", "rb"
         run_prototype_file(format, args)
       when "runtime"
-        require_libs = []
-        relative_libs = []
+        require_libs = [] #: Array[String]
+        relative_libs = [] #: Array[String]
         merge = false
         todo = false
-        owners_included = []
+        owners_included = [] #: Array[Symbol]
         outline = false
         autoload = false
 
@@ -591,7 +591,7 @@ def run_prototype(args, options)
             todo = true
           end
           opts.on("--method-owner CLASS", "Generate method prototypes if the owner of the method is [CLASS]") do |klass|
-            owners_included << klass
+            owners_included << klass.to_sym
           end
           opts.on("--outline", "Generates only module/class/constant declaration (no method definition)") do
             outline = true
@@ -615,9 +615,9 @@ def autoload(name, path)
             ::Module.prepend(hook)
             ::Kernel.prepend(hook)
 
-            arguments = []
+            arguments = [] #: Array[[Module, interned]]
             TracePoint.new(:call) do |tp|
-              base = tp.self.kind_of?(Module) ? tp.self : Kernel
+              base = tp.self.kind_of?(Module) ? tp.self : Kernel #: Module
               name = (tp.binding or raise).local_variable_get(:name)
               arguments << [base, name]
             end.enable(target: hook.instance_method(:autoload), &block)
@@ -979,7 +979,7 @@ def run_annotate(args, options)
     end
 
     def test_opt options
-      opts = []
+      opts = [] #: Array[String]
 
       opts.push(*options.repos.map {|dir| "--repo #{Shellwords.escape(dir)}"})
       opts.push(*options.dirs.map {|dir| "-I #{Shellwords.escape(dir)}"})
@@ -1056,7 +1056,7 @@ def run_collection(args, options)
       require 'bundler'
 
       opts = collection_options(args)
-      params = {}
+      params = {} #: Hash[Symbol, untyped]
       opts.order args.drop(1), into: params
       config_path = options.config_path or raise
       lock_path = Collection::Config.to_lockfile_path(config_path)

lib/rbs/cli/diff.rb

@@ -11,8 +11,8 @@ def initialize(argv:, library_options:, stdout: $stdout, stderr: $stderr)
         # @type var type_name: String?
         type_name = nil
         library_options = library_options
-        before_path = []
-        after_path = []
+        before_path = [] #: Array[String]
+        after_path = [] #: Array[String]
         detail = false
 
         opt = OptionParser.new do |o|

lib/rbs/collection/config.rb

@@ -72,7 +72,9 @@ def sources
       end
 
       def gems
-        @data['gems'] ||= []
+        @data['gems'] ||= (
+          [] #: Array[gem_entry]
+        )
       end
     end
   end

lib/rbs/definition_builder/ancestor_builder.rb

@@ -209,7 +209,7 @@ def one_instance_ancestors(type_name)
               super_args = super_class.args
             else
               super_name = BuiltinNames::Object.name
-              super_args = []
+              super_args = [] #: Array[Types::t]
             end
 
             super_name = env.normalize_module_name(super_name)
@@ -525,7 +525,7 @@ def singleton_ancestors(type_name, building_ancestors: [])
 
         one_ancestors = one_singleton_ancestors(type_name)
 
-        ancestors = []
+        ancestors = [] #: Array[Definition::Ancestor::t]
 
         case super_class = one_ancestors.super_class
         when Definition::Ancestor::Instance
@@ -581,7 +581,7 @@ def interface_ancestors(type_name, building_ancestors: [])
         building_ancestors.push self_ancestor
 
         one_ancestors = one_interface_ancestors(type_name)
-        ancestors = []
+        ancestors = [] #: Array[Definition::Ancestor::t]
 
         included_interfaces = one_ancestors.included_interfaces or raise
         included_interfaces.each do |a|

lib/rbs/environment_loader.rb

@@ -26,7 +26,7 @@ class Library < Struct.new(:name, :version, keyword_init: true)
     DEFAULT_CORE_ROOT = Pathname(_ = __dir__) + "../../core"
 
     def self.gem_sig_path(name, version)
-      requirements = []
+      requirements = [] #: Array[String]
       requirements << version if version
       spec = Gem::Specification.find_by_name(name, *requirements)
       path = Pathname(spec.gem_dir) + "sig"

lib/rbs/parser_aux.rb

@@ -70,8 +70,8 @@ def self.buffer(source)
       untyped
       true
       false
-      ).each_with_object({}) do |keyword, hash|
-        hash[keyword] = nil
+      ).each_with_object({}) do |keyword, hash| #$ Hash[String, bot]
+        hash[keyword] = _ = nil
       end
   end
 end

lib/rbs/prototype/rb.rb

@@ -75,8 +75,8 @@ def decls
       def parse(string)
         # @type var comments: Hash[Integer, AST::Comment]
         comments = Ripper.lex(string).yield_self do |tokens|
-          code_lines = {}
-          tokens.each.with_object({}) do |token, hash|
+          code_lines = {} #: Hash[Integer, bool]
+          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
             case token[1]
             when :on_sp, :on_ignored_nl
               # skip
@@ -643,11 +643,11 @@ def literal_to_type(node)
             children = list.children
             children.pop
           else
-            children = []
+            children = [] #: Array[untyped]
           end
 
-          key_types = []
-          value_types = []
+          key_types = [] #: Array[Types::t]
+          value_types = [] #: Array[Types::t]
           children.each_slice(2) do |k, v|
             if k
               key_types << literal_to_type(k)
@@ -659,7 +659,10 @@ def literal_to_type(node)
           end
 
           if !key_types.empty? && key_types.all? { |t| t.is_a?(Types::Literal) }
-            fields = key_types.map { |t| t.literal }.zip(value_types).to_h
+            fields = key_types.map {|t|
+              t.is_a?(Types::Literal) or raise
+              t.literal
+            }.zip(value_types).to_h #: Hash[Types::Literal::literal, Types::t]
             Types::Record.new(fields: fields, location: nil)
           else
             key_type = types_to_union_type(key_types)

lib/rbs/prototype/rbi.rb

@@ -17,9 +17,7 @@ def initialize
 
       def parse(string)
         comments = Ripper.lex(string).yield_self do |tokens|
-          tokens.each.with_object({}) do |token, hash|
-            # @type var hash: Hash[Integer, AST::Comment]
-
+          tokens.each.with_object({}) do |token, hash| #$ Hash[Integer, AST::Comment]
             if token[1] == :on_comment
               line = token[0][0]
               body = token[2][2..-1] or raise
@@ -325,11 +323,17 @@ def method_type(args_node, type_node, variables:, overloads:)
               end
             end
           when :type_parameters
-            type_params = []
+            type_params = [] #: Array[AST::TypeParam]
 
             each_arg args do |node|
               if name = symbol_literal_node?(node)
-                type_params << name
+                type_params << AST::TypeParam.new(
+                  name: name,
+                  variance: :invariant,
+                  upper_bound: nil,
+                  location: nil,
+                  default_type: nil
+                )
               end
             end
 

lib/rbs/prototype/runtime.rb

@@ -48,7 +48,8 @@ def skip_constant?(module_name:, name:)
 
         def mixin_decls(type_name)
           type_name_absolute = type_name.absolute!
-          (@mixin_decls_cache ||= {}).fetch(type_name_absolute) do
+          @mixin_decls_cache ||= {} #: Hash[TypeName, Array[AST::Members::Mixin]]
+          @mixin_decls_cache.fetch(type_name_absolute) do
             @mixin_decls_cache[type_name_absolute] = @builder.env.class_decls[type_name_absolute].decls.flat_map do |d|
               d.decl.members.select { |m| m.kind_of?(AST::Members::Mixin) }
             end