rbs 2.5.1 → 2.6.0

data/lib/rbs/prototype/rbi.rb

@@ -14,17 +14,20 @@ module RBS
       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]
+
             if token[1] == :on_comment
               line = token[0][0]
-              body = token[2][2..-1]
+              body = token[2][2..-1] or raise
 
               body = "\n" if body.empty?
 
               comment = AST::Comment.new(string: body, location: nil)
-              if (prev_comment = hash[line - 1])
-                hash[line - 1] = nil
-                hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
-                                              location: nil)
+              if (prev_comment = hash.delete(line - 1))
+                hash[line] = AST::Comment.new(
+                  string: prev_comment.string + comment.string,
+                  location: nil
+                )
               else
                 hash[line] = comment
               end
@@ -45,7 +48,7 @@ module RBS
       end
 
       def push_class(name, super_class, comment:)
-        modules.push AST::Declarations::Class.new(
+        class_decl = AST::Declarations::Class.new(
           name: nested_name(name),
           super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
           type_params: [],
@@ -55,7 +58,8 @@ module RBS
           comment: comment
         )
 
-        decls << modules.last
+        modules << class_decl
+        decls << class_decl
 
         yield
       ensure
@@ -63,7 +67,7 @@ module RBS
       end
 
       def push_module(name, comment:)
-        modules.push AST::Declarations::Module.new(
+        module_decl = AST::Declarations::Module.new(
           name: nested_name(name),
           type_params: [],
           members: [],
@@ -73,7 +77,8 @@ module RBS
           comment: comment
         )
 
-        decls << modules.last
+        modules << module_decl
+        decls << module_decl
 
         yield
       ensure
@@ -84,9 +89,16 @@ module RBS
         modules.last
       end
 
+      def current_module!
+        current_module or raise
+      end
+
       def push_sig(node)
-        @last_sig ||= []
-        @last_sig << node
+        if last_sig = @last_sig
+          last_sig << node
+        else
+          @last_sig = [node]
+        end
       end
 
       def pop_sig
@@ -125,7 +137,7 @@ module RBS
                   location: nil,
                   comment: nil
                 )
-                current_module.members << include_member
+                current_module!.members << include_member
               end
             end
           when :extend
@@ -140,15 +152,16 @@ module RBS
                     location: nil,
                     comment: nil
                   )
-                  current_module.members << member
+                  current_module!.members << member
                 end
               end
             end
           when :sig
-            push_sig outer.last.children.last.children.last
+            out = outer.last or raise
+            push_sig out.children.last.children.last
           when :alias_method
             new, old = each_arg(node.children[1]).map {|x| x.children[0] }
-            current_module.members << AST::Members::Alias.new(
+            current_module!.members << AST::Members::Alias.new(
               new_name: new,
               old_name: old,
               location: nil,
@@ -164,9 +177,9 @@ module RBS
             comment = join_comments(sigs, comments)
 
             args = node.children[2]
-            types = sigs.map {|sig| method_type(args, sig, variables: current_module.type_params) }
+            types = sigs.map {|sig| method_type(args, sig, variables: current_module!.type_params, overloads: sigs.size) }.compact
 
-            current_module.members << AST::Members::MethodDefinition.new(
+            current_module!.members << AST::Members::MethodDefinition.new(
               name: node.children[1],
               location: nil,
               annotations: [],
@@ -184,9 +197,9 @@ module RBS
             comment = join_comments(sigs, comments)
 
             args = node.children[1]
-            types = sigs.map {|sig| method_type(args, sig, variables: current_module.type_params) }
+            types = sigs.map {|sig| method_type(args, sig, variables: current_module!.type_params, overloads: sigs.size) }.compact
 
-            current_module.members << AST::Members::MethodDefinition.new(
+            current_module!.members << AST::Members::MethodDefinition.new(
               name: node.children[0],
               location: nil,
               annotations: [],
@@ -203,7 +216,8 @@ module RBS
               node.type == :HASH &&
                 each_arg(node.children[0]).each_slice(2).any? {|a, _| a.type == :LIT && a.children[0] == :fixed }
             }
-              if (a0 = each_arg(send.children[1]).to_a[0])&.type == :LIT
+              # @type var variance: AST::TypeParam::variance?
+              if (a0 = each_arg(send.children[1]).to_a[0]) && a0.type == :LIT
                 variance = case a0.children[0]
                            when :out
                              :covariant
@@ -212,7 +226,7 @@ module RBS
                            end
               end
 
-              current_module.type_params << AST::TypeParam.new(
+              current_module!.type_params << AST::TypeParam.new(
                 name: node.children[0],
                 variance: variance || :invariant,
                 location: nil,
@@ -242,7 +256,7 @@ module RBS
             )
           end
         when :ALIAS
-          current_module.members << AST::Members::Alias.new(
+          current_module!.members << AST::Members::Alias.new(
             new_name: node.children[0].children[0],
             old_name: node.children[1].children[0],
             location: nil,
@@ -257,10 +271,10 @@ module RBS
         end
       end
 
-      def method_type(args_node, type_node, variables:)
+      def method_type(args_node, type_node, variables:, overloads:)
         if type_node
           if type_node.type == :CALL
-            method_type = method_type(args_node, type_node.children[0], variables: variables)
+            method_type = method_type(args_node, type_node.children[0], variables: variables, overloads: overloads) or raise
           else
             method_type = MethodType.new(
               type: Types::Function.empty(Types::Bases::Any.new(location: nil)),
@@ -289,7 +303,7 @@ module RBS
             method_type.update(type: method_type.type.with_return_type(type_of(return_type, variables: variables)))
           when :params
             if args_node
-              parse_params(args_node, args, method_type, variables: variables)
+              parse_params(args_node, args, method_type, variables: variables, overloads: overloads)
             else
               vars = (node_to_hash(each_arg(args).to_a[0]) || {}).transform_values {|value| type_of(value, variables: variables) }
 
@@ -319,15 +333,22 @@ module RBS
         end
       end
 
-      def parse_params(args_node, args, method_type, variables:)
+      def parse_params(args_node, args, method_type, variables:, overloads:)
         vars = (node_to_hash(each_arg(args).to_a[0]) || {}).transform_values {|value| type_of(value, variables: variables) }
 
+        # @type var required_positionals: Array[Types::Function::Param]
         required_positionals = []
+        # @type var optional_positionals: Array[Types::Function::Param]
         optional_positionals = []
+        # @type var rest_positionals: Types::Function::Param?
         rest_positionals = nil
+        # @type var trailing_positionals: Array[Types::Function::Param]
         trailing_positionals = []
+        # @type var required_keywords: Hash[Symbol, Types::Function::Param]
         required_keywords = {}
+        # @type var optional_keywords: Hash[Symbol, Types::Function::Param]
         optional_keywords = {}
+        # @type var rest_keywords: Types::Function::Param?
         rest_keywords = nil
 
         var_names = args_node.children[0]
@@ -396,8 +417,8 @@ module RBS
                 type: Types::Function.empty(Types::Bases::Any.new(location: nil))
               )
             # Handle an optional block like `T.nilable(T.proc.void)`.
-            elsif type.is_a?(Types::Optional) && type.type.is_a?(Types::Proc)
-              method_block = Types::Block.new(required: false, type: type.type.type)
+            elsif type.is_a?(Types::Optional) && (proc_type = type.type).is_a?(Types::Proc)
+              method_block = Types::Block.new(required: false, type: proc_type.type)
             else
               STDERR.puts "Unexpected block type: #{type}"
               PP.pp args_node, STDERR
@@ -406,6 +427,13 @@ module RBS
                 type: Types::Function.empty(Types::Bases::Any.new(location: nil))
               )
             end
+          else
+            if overloads == 1
+              method_block = Types::Block.new(
+                required: false,
+                type: Types::Function.empty(Types::Bases::Any.new(location: nil))
+              )
+            end
           end
         end
 
@@ -439,7 +467,7 @@ module RBS
       def type_of0(type_node, variables:)
         case
         when type_node.type == :CONST
-          if variables.each.include?(type_node.children[0])
+          if variables.include?(type_node.children[0])
             Types::Variable.new(name: type_node.children[0], location: nil)
           else
             Types::ClassInstance.new(name: const_to_name(type_node), args: [], location: nil)
@@ -447,7 +475,10 @@ module RBS
         when type_node.type == :COLON2
           Types::ClassInstance.new(name: const_to_name(type_node), args: [], location: nil)
         when call_node?(type_node, name: :[], receiver: -> (_) { true })
+          # The type_node represents a type application
           type = type_of(type_node.children[0], variables: variables)
+          type.is_a?(Types::ClassInstance) or raise
+
           each_arg(type_node.children[2]) do |arg|
             type.args << type_of(arg, variables: variables)
           end
@@ -487,7 +518,8 @@ module RBS
           Types::Tuple.new(types: types, location: nil)
         else
           if proc_type?(type_node)
-            Types::Proc.new(type: method_type(nil, type_node, variables: variables).type, block: nil, location: nil)
+            method_type = method_type(nil, type_node, variables: variables, overloads: 1) or raise
+            Types::Proc.new(type: method_type.type, block: nil, location: nil)
           else
             STDERR.puts "Unexpected type_node:"
             PP.pp type_node, STDERR
@@ -572,9 +604,12 @@ module RBS
 
       def node_to_hash(node)
         if node&.type == :HASH
+          # @type var hash: Hash[Symbol, untyped]
           hash = {}
 
           each_arg(node.children[0]).each_slice(2) do |var, type|
+            var or raise
+
             if var.type == :LIT && type
               hash[var.children[0]] = type
             end

data/lib/rbs/prototype/runtime.rb

@@ -341,7 +341,7 @@ module RBS
                  end
 
           decls << AST::Declarations::Constant.new(
-            name: name,
+            name: to_type_name(name.to_s),
             type: type,
             location: nil,
             comment: nil
@@ -470,8 +470,9 @@ module RBS
         *outer_module_names, _ = const_name(mod).split(/::/) #=> parent = [A, B], mod = C
         destination = @decls # Copy the entries in ivar @decls, not .dup
 
-        outer_module_names&.each do |outer_module_name|
-          outer_module = @modules.detect { |x| const_name(x) == outer_module_name }
+        outer_module_names&.each_with_index do |outer_module_name, i|
+          current_name = outer_module_names[0, i + 1].join('::')
+          outer_module = @modules.detect { |x| const_name(x) == current_name }
           outer_decl = destination.detect { |decl| decl.is_a?(outer_module.is_a?(Class) ? AST::Declarations::Class : AST::Declarations::Module) && decl.name.name == outer_module_name.to_sym }
 
           # Insert AST::Declarations if declarations are not added previously

data/lib/rbs/test/setup_helper.rb

@@ -30,7 +30,12 @@ module RBS
 
         case double_suite.downcase.strip
         when 'rspec'
-          ['::RSpec::Mocks::Double']
+          [
+            '::RSpec::Mocks::Double',
+            '::RSpec::Mocks::InstanceVerifyingDouble',
+            '::RSpec::Mocks::ObjectVerifyingDouble',
+            '::RSpec::Mocks::ClassVerifyingDouble',
+          ]
         when 'minitest'
           ['::Minitest::Mock']
         else

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "2.5.1"
+  VERSION = "2.6.0"
 end

data/schema/members.json

@@ -202,9 +202,12 @@
         },
         "location": {
           "$ref": "location.json"
+        },
+        "visibility": {
+          "enum": ["public", "private", null]
         }
       },
-      "required": ["member", "name", "ivar_name", "type", "annotations", "kind", "comment", "location"]
+      "required": ["member", "name", "ivar_name", "type", "annotations", "kind", "comment", "location", "visibility"]
     },
     "visibility": {
       "title": "Visibility specifier",

data/sig/collection/config.rbs

@@ -2,6 +2,9 @@ module RBS
   module Collection
     # This class represent the configration file.
     class Config
+      class CollectionNotAvailable < StandardError
+      end
+
       class LockfileGenerator
         attr_reader config: Config
         attr_reader lock: Config?

data/sig/factory.rbs

@@ -0,0 +1,5 @@
+module RBS
+  class Factory
+    def type_name: (String) -> TypeName
+  end
+end

data/sig/prototype/helpers.rbs

@@ -0,0 +1,23 @@
+module RBS
+  module Prototype
+    module Helpers
+      type node = RubyVM::AbstractSyntaxTree::Node
+
+      def block_from_body: (node) -> Types::Block?
+
+      def each_node: (Array[untyped] nodes) { (node) -> void } -> void
+
+      def each_child: (node) { (node child) -> void } -> void
+
+      def any_node?: (node, ?nodes: Array[node]) { (node) -> bool } -> Array[node]?
+
+      def keyword_hash?: (node) -> bool
+
+      def args_from_node: (node?) -> Array[untyped]
+
+      def untyped: () -> Types::Bases::Any
+
+      @untyped: Types::Bases::Any
+    end
+  end
+end

data/sig/prototype/rb.rbs

@@ -0,0 +1,84 @@
+module RBS
+  module Prototype
+    class RB
+      include Helpers
+
+      class Context
+        type method_kind = :singleton | :singleton_instance | :instance
+
+        attr_accessor module_function: bool
+
+        attr_accessor singleton: bool
+
+        attr_accessor namespace: Namespace
+
+        def initialize: (module_function: bool, singleton: bool, namespace: Namespace) -> void
+
+        def method_kind: () -> method_kind
+
+        def attribute_kind: () -> (:singleton | :instance)
+
+        def self.initial: (?namespace: Namespace) -> Context
+      end
+
+      type decl = AST::Declarations::t | AST::Members::t
+
+      attr_reader source_decls: Array[decl]
+
+      def initialize: () -> void
+
+      def decls: () -> Array[AST::Declarations::t]
+
+      def parse: (String) -> void
+
+      def process: (untyped node, decls: Array[AST::Declarations::t | AST::Members::t], comments: Hash[Integer, AST::Comment], context: Context) -> void
+
+      def process_children: (RubyVM::AbstractSyntaxTree::Node node, decls: Array[decl], comments: Hash[Integer, AST::Comment], context: Context) -> void
+
+      # Returns a type name that represents the name of the constant.
+      # `node` must be _constant_ node, `CONST`, `COLON2`, or `COLON3` node.
+      #
+      def const_to_name!: (RubyVM::AbstractSyntaxTree::Node node) -> TypeName
+
+      # Returns a type name that represents the name of the constant.
+      # `node` can be `SELF` for `extend self` pattern.
+      #
+      def const_to_name: (RubyVM::AbstractSyntaxTree::Node? node, context: Context) -> TypeName?
+
+      def literal_to_symbol: (RubyVM::AbstractSyntaxTree::Node node) -> Symbol?
+
+      def function_type_from_body: (RubyVM::AbstractSyntaxTree::Node node, Symbol def_name) -> Types::Function
+
+      def function_return_type_from_body: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def body_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def if_unless_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def block_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def literal_to_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def types_to_union_type: (Array[Types::t] types) -> Types::t
+
+      def range_element_type: (Array[Types::t] types) -> Types::t
+
+      def param_type: (RubyVM::AbstractSyntaxTree::Node node, ?default: Types::Bases::Any) -> Types::t
+
+      # backward compatible
+      alias node_type param_type
+
+      def private: () -> AST::Members::Private
+
+      def public: () -> AST::Members::Public
+
+      def current_accessibility: (Array[decl] decls, ?Integer index) -> (AST::Members::Private | AST::Members::Public)
+
+      def remove_unnecessary_accessibility_methods!: (Array[decl]) -> void
+
+      def is_accessibility?: (decl) -> bool
+
+      def find_def_index_by_name: (Array[decl] decls, Symbol name) -> [Integer, AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrWriter]?
+    end
+  end
+end

data/sig/prototype/rbi.rbs

@@ -0,0 +1,73 @@
+module RBS
+  module Prototype
+    class RBI
+      attr_reader decls: Array[AST::Declarations::t]
+
+      type module_decl = AST::Declarations::Class | AST::Declarations::Module
+
+      # A stack representing the module nesting structure in the Ruby code
+      attr_reader modules: Array[module_decl]
+
+      # Last subsequent `sig` calls
+      attr_reader last_sig: Array[RubyVM::AbstractSyntaxTree::Node]?
+
+      def initialize: () -> void
+
+      def parse: (String) -> void
+
+      def nested_name: (RubyVM::AbstractSyntaxTree::Node name) -> TypeName
+
+      def current_namespace: () -> Namespace
+
+      def push_class: (
+        RubyVM::AbstractSyntaxTree::Node name,
+        RubyVM::AbstractSyntaxTree::Node super_class,
+        comment: AST::Comment?
+      ) { () -> void } -> void
+
+      def push_module: (RubyVM::AbstractSyntaxTree::Node name, comment: AST::Comment?) { () -> void } -> void
+
+      # The inner most module/class definition, returns `nil` on toplevel
+      def current_module: () -> module_decl?
+
+      # The inner most module/class definition, raises on toplevel
+      def current_module!: () -> module_decl
+
+      # Put a `sig` call to current list.
+      def push_sig: (RubyVM::AbstractSyntaxTree::Node node) -> void
+
+      # Clear the `sig` call list
+      def pop_sig: () -> Array[RubyVM::AbstractSyntaxTree::Node]?
+
+      def join_comments: (Array[RubyVM::AbstractSyntaxTree::Node] nodes, Hash[Integer, AST::Comment] comments) -> AST::Comment
+
+      def process: (RubyVM::AbstractSyntaxTree::Node node, comments: Hash[Integer, AST::Comment], ?outer: Array[RubyVM::AbstractSyntaxTree::Node]) -> void
+
+      def method_type: (RubyVM::AbstractSyntaxTree::Node? args_node, RubyVM::AbstractSyntaxTree::Node? type_node, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType?
+
+      def parse_params: (RubyVM::AbstractSyntaxTree::Node args_node, RubyVM::AbstractSyntaxTree::Node args, MethodType method_type, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType
+
+      def type_of: (RubyVM::AbstractSyntaxTree::Node type_node, variables: Array[AST::TypeParam]) -> Types::t
+
+      def type_of0: (RubyVM::AbstractSyntaxTree::Node type_node, variables: Array[AST::TypeParam]) -> Types::t
+
+      def proc_type?: (RubyVM::AbstractSyntaxTree::Node type_node) -> bool
+
+      def call_node?: (RubyVM::AbstractSyntaxTree::Node node, name: Symbol, ?receiver: ^(RubyVM::AbstractSyntaxTree::Node) -> bool, ?args: ^(RubyVM::AbstractSyntaxTree::Node) -> bool) -> bool
+
+      # Receives a constant node and returns `TypeName` instance
+      def const_to_name: (RubyVM::AbstractSyntaxTree::Node node) -> TypeName
+
+      # Receives `:ARRAY` or `:LIST` node and yields the child nodes.
+      def each_arg: (RubyVM::AbstractSyntaxTree::Node array) { (RubyVM::AbstractSyntaxTree::Node) -> void } -> void
+                  | (RubyVM::AbstractSyntaxTree::Node array) -> Enumerator[RubyVM::AbstractSyntaxTree::Node, void]
+
+      # Receives node and yields the child nodes.
+      def each_child: (RubyVM::AbstractSyntaxTree::Node node) { (RubyVM::AbstractSyntaxTree::Node) -> void } -> void
+                    | (RubyVM::AbstractSyntaxTree::Node node) -> Enumerator[RubyVM::AbstractSyntaxTree::Node, void]
+
+      # Receives a keyword `:HASH` node and returns hash instance.
+      def node_to_hash: (RubyVM::AbstractSyntaxTree::Node node) -> Hash[Symbol, RubyVM::AbstractSyntaxTree::Node]?
+    end
+  end
+end

data/sig/shims/abstract_syntax_tree.rbs

@@ -0,0 +1,25 @@
+class RubyVM
+  module AbstractSyntaxTree
+    def self.parse: (String src) -> Node
+
+    def self.parse_file: (String pathname) -> Node
+
+    def self.of: (untyped proc) -> Node
+
+    class Node
+      attr_reader children (): Array[untyped]
+
+      attr_reader first_column (): Integer
+
+      attr_reader first_lineno (): Integer
+
+      attr_reader last_column (): Integer
+
+      attr_reader last_lineno (): Integer
+
+      attr_reader type (): Symbol
+
+      def inspect: () -> String
+    end
+  end
+end

data/sig/shims/enumerable.rbs

@@ -0,0 +1,5 @@
+module Enumerable[unchecked out Elem] : _Each[Elem]
+  def each_slice: (2) { ([Elem, Elem]) -> void } -> void
+                | (2) -> Enumerator[[Elem, Elem], void]
+                | ...
+end

data/sig/shims/pp.rbs

@@ -0,0 +1,3 @@
+class PP
+  def self.pp: (untyped obj, IO out, ?Integer width) -> void
+end

data/sig/shims/ripper.rbs

@@ -0,0 +1,8 @@
+class Ripper
+  def self.lex: (String src, ?String filename, ?Integer lineno, ?raise_errors: bool) -> Array[[[Integer, Integer], Symbol, String, Lexer::State]]
+
+  class Lexer
+    class State
+    end
+  end
+end

data/stdlib/cgi/0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: tempfile

data/stdlib/date/0/time.rbs

@@ -0,0 +1,26 @@
+%a{annotate:rdoc:skip}
+class Time
+  # <!--
+  #   rdoc-file=ext/date/date_core.c
+  #   - t.to_time  ->  time
+  # -->
+  # Returns self.
+  #
+  def to_time: () -> Time
+
+  # <!--
+  #   rdoc-file=ext/date/date_core.c
+  #   - t.to_date  ->  date
+  # -->
+  # Returns a Date object which denotes self.
+  #
+  def to_date: () -> Date
+
+  # <!--
+  #   rdoc-file=ext/date/date_core.c
+  #   - t.to_datetime  ->  datetime
+  # -->
+  # Returns a DateTime object which denotes self.
+  #
+  def to_datetime: () -> DateTime
+end