rbs 2.8.4 → 3.0.0.dev.1

data/lib/rbs/environment.rb

@@ -365,11 +365,13 @@ module RBS
         AST::Members::MethodDefinition.new(
           name: member.name,
           kind: member.kind,
-          types: member.types.map do |type|
-            resolve_method_type(resolver, type, context: context)
+          overloads: member.overloads.map do |overload|
+            overload.update(
+              method_type: resolve_method_type(resolver, overload.method_type, context: context)
+            )
           end,
           comment: member.comment,
-          overload: member.overload?,
+          overloading: member.overloading?,
           annotations: member.annotations,
           location: member.location,
           visibility: member.visibility

data/lib/rbs/environment_loader.rb

@@ -60,25 +60,26 @@ module RBS
 
     def resolve_dependencies(library:, version:)
       [Collection::Sources::Rubygems.instance, Collection::Sources::Stdlib.instance].each do |source|
-        # @type var gem: { 'name' => String, 'version' => String? }
-        gem = { 'name' => library, 'version' => version }
-        next unless source.has?(gem)
+        next unless source.has?(library, version)
 
-        gem['version'] ||= source.versions(gem).last
-        source.dependencies_of(gem)&.each do |dep|
+        unless version
+          version = source.versions(library).last or raise
+        end
+
+        source.dependencies_of(library, version)&.each do |dep|
           add(library: dep['name'], version: nil)
         end
         return
       end
     end
 
-    def add_collection(collection_config)
-      collection_config.check_rbs_availability!
+    def add_collection(lockfile)
+      lockfile.check_rbs_availability!
 
-      repository.add(collection_config.repo_path)
+      repository.add(lockfile.fullpath)
 
-      collection_config.gems.each do |gem|
-        add(library: gem['name'], version: gem['version'], resolve_dependencies: false)
+      lockfile.gems.each_value do |gem|
+        add(library: gem[:name], version: gem[:version], resolve_dependencies: false)
       end
     end
 

data/lib/rbs/locator.rb

@@ -113,8 +113,8 @@ module RBS
 
         case member
         when AST::Members::MethodDefinition
-          member.types.each do |method_type|
-            find_in_method_type(pos, array: array, method_type: method_type) and return true
+          member.overloads.each do |overload|
+            find_in_method_type(pos, array: array, method_type: overload.method_type) and return true
           end
         when AST::Members::InstanceVariable, AST::Members::ClassInstanceVariable, AST::Members::ClassVariable
           find_in_type(pos, array: array, type: member.type) and return true

data/lib/rbs/prototype/helpers.rb

@@ -7,27 +7,43 @@ module RBS
 
       def block_from_body(node)
         _, args_node, body_node = node.children
+        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block_var = args_from_node(args_node)
 
-        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_from_node(args_node)
+        # @type var body_node: node?
+        if body_node
+          yields = any_node?(body_node) {|n| n.type == :YIELD }
+        end
+
+        if yields || block_var
+          required = true
+
+          if body_node
+            if any_node?(body_node) {|n| n.type == :FCALL && n.children[0] == :block_given? && !n.children[1] }
+              required = false
+            end
+          end
+
+          if _rest == :* && block_var == :&
+            # ... is given
+            required = false
+          end
 
-        method_block = nil
+          if block_var
+            if body_node
+              usage = NodeUsage.new(body_node)
+              if usage.each_conditional_node.any? {|n| n.type == :LVAR && n.children[0] == block_var }
+                required = false
+              end
+            end
+          end
 
-        if block
           method_block = Types::Block.new(
-            required: false,
+            required: required,
             type: Types::Function.empty(untyped),
             self_type: nil
           )
-        end
-
-        if body_node
-          if (yields = any_node?(body_node) {|n| n.type == :YIELD })
-            method_block = Types::Block.new(
-              required: true,
-              type: Types::Function.empty(untyped),
-              self_type: nil
-            )
 
+          if yields
             yields.each do |yield_node|
               array_content = yield_node.children[0]&.children&.compact || []
 

data/lib/rbs/prototype/node_usage.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RBS
+  module Prototype
+    class NodeUsage
+      include Helpers
+
+      attr_reader :conditional_nodes
+
+      def initialize(node)
+        @node = node
+        @conditional_nodes = Set[].compare_by_identity
+
+        calculate(node, conditional: false)
+      end
+
+      def each_conditional_node(&block)
+        if block
+          conditional_nodes.each(&block)
+        else
+          conditional_nodes.each
+        end
+      end
+
+      def calculate(node, conditional:)
+        if conditional
+          conditional_nodes << node
+        end
+
+        case node.type
+        when :IF, :UNLESS
+          cond_node, true_node, false_node = node.children
+          calculate(cond_node, conditional: true)
+          calculate(true_node, conditional: conditional) if true_node
+          calculate(false_node, conditional: conditional) if false_node
+        when :AND, :OR
+          left, right = node.children
+          calculate(left, conditional: true)
+          calculate(right, conditional: conditional)
+        when :QCALL
+          receiver, _, args = node.children
+          calculate(receiver, conditional: true)
+          calculate(args, conditional: false) if args
+        when :WHILE
+          cond, body = node.children
+          calculate(cond, conditional: true)
+          calculate(body, conditional: false) if body
+        when :OP_ASGN_OR, :OP_ASGN_AND
+          var, _, asgn = node.children
+          calculate(var, conditional: true)
+          calculate(asgn, conditional: conditional)
+        when :LASGN, :IASGN, :GASGN
+          _, lhs = node.children
+          calculate(lhs, conditional: conditional) if lhs
+        when :MASGN
+          lhs, _ = node.children
+          calculate(lhs, conditional: conditional)
+        when :CDECL
+          if node.children.size == 2
+            _, lhs = node.children
+            calculate(lhs, conditional: conditional)
+          else
+            const, _, lhs = node.children
+            calculate(const, conditional: false)
+            calculate(lhs, conditional: conditional)
+          end
+        when :SCOPE
+          _, _, body = node.children
+          calculate(body, conditional: conditional)
+        when :CASE2
+          _, *branches = node.children
+          branches.each do |branch|
+            if branch.type == :WHEN
+              list, body = branch.children
+              list.children.each do |child|
+                if child
+                  calculate(child, conditional: true)
+                end
+              end
+              calculate(body, conditional: conditional)
+            else
+              calculate(branch, conditional: conditional)
+            end
+          end
+        when :BLOCK
+          *nodes, last = node.children
+          nodes.each do |no|
+            calculate(no, conditional: false)
+          end
+          calculate(last, conditional: conditional) if last
+        else
+          each_child(node) do |child|
+            calculate(child, conditional: false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/prototype/rb.rb

@@ -186,10 +186,11 @@ module RBS
             name: def_name,
             location: nil,
             annotations: [],
-            types: types,
+            overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type )},
             kind: kind,
             comment: comments[node.first_lineno - 1],
-            overload: false
+            overloading: false,
+            visibility: nil
           )
 
           decls.push member unless decls.include?(member)

data/lib/rbs/prototype/rbi.rb

@@ -185,10 +185,11 @@ module RBS
               name: node.children[1],
               location: nil,
               annotations: [],
-              types: types,
+              overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type) },
               kind: :singleton,
               comment: comment,
-              overload: false
+              overloading: false,
+              visibility: nil
             )
           end
 
@@ -205,10 +206,11 @@ module RBS
               name: node.children[0],
               location: nil,
               annotations: [],
-              types: types,
+              overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type) },
               kind: :instance,
               comment: comment,
-              overload: false
+              overloading: false,
+              visibility: nil
             )
           end
 

data/lib/rbs/prototype/runtime.rb

@@ -187,18 +187,22 @@ module RBS
             if method
               members << AST::Members::MethodDefinition.new(
                 name: method_name,
-                types: method.method_types.map {|type|
-                  type.update.tap do |ty|
-                    def ty.to_s
-                      location.source
+                overloads: method.method_types.map {|type|
+                  AST::Members::MethodDefinition::Overload.new(
+                    annotations: [],
+                    method_type: type.update.tap do |ty|
+                      def ty.to_s
+                        location.source
+                      end
                     end
-                  end
+                  )
                 },
                 kind: kind,
                 location: nil,
                 comment: method.comments[0],
                 annotations: method.annotations,
-                overload: false
+                overloading: false,
+                visibility: nil
               )
               return
             end
@@ -231,12 +235,15 @@ module RBS
 
               members << AST::Members::MethodDefinition.new(
                 name: method.name,
-                types: [method_type(method)],
+                overloads: [
+                  AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type(method))
+                ],
                 kind: :singleton,
                 location: nil,
                 comment: nil,
                 annotations: [],
-                overload: false
+                overloading: false,
+                visibility: nil
               )
             end
           else
@@ -264,12 +271,15 @@ module RBS
 
                 members << AST::Members::MethodDefinition.new(
                   name: method.name,
-                  types: [method_type(method)],
+                  overloads: [
+                    AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type(method))
+                  ],
                   kind: :instance,
                   location: nil,
                   comment: nil,
                   annotations: [],
-                  overload: false
+                  overloading: false,
+                  visibility: nil
                 )
               end
             else
@@ -298,12 +308,15 @@ module RBS
 
                 members << AST::Members::MethodDefinition.new(
                   name: method.name,
-                  types: [method_type(method)],
+                  overloads: [
+                    AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type(method))
+                  ],
                   kind: :instance,
                   location: nil,
                   comment: nil,
                   annotations: [],
-                  overload: false
+                  overloading: false,
+                  visibility: nil
                 )
               end
             else

data/lib/rbs/substitution.rb

@@ -50,6 +50,8 @@ module RBS
       end
     end
 
+    alias [] apply
+
     def without(*vars)
       Substitution.new.tap do |subst|
         subst.mapping.merge!(mapping)
@@ -60,5 +62,22 @@ module RBS
         subst.instance_type = self.instance_type
       end
     end
+
+    def +(other)
+      return self if other.empty?
+      return other if self.empty?
+
+      Substitution.new.tap do |subst|
+        subst.mapping.merge!(mapping)
+
+        other.mapping.each do |var, type|
+          if mapping.key?(var)
+            subst.add(from: var, to: self[type])
+          else
+            subst.add(from: var, to: type)
+          end
+        end
+      end
+    end
   end
 end

data/lib/rbs/types.rb

@@ -757,11 +757,7 @@ module RBS
 
         def to_s
           if name
-            if Parser::KEYWORDS.include?(name.to_s)
-              "#{type} `#{name}`"
-            else
-              "#{type} #{name}"
-            end
+            "#{type} #{name}"
           else
             "#{type}"
           end

data/lib/rbs/validator.rb

@@ -98,7 +98,8 @@ module RBS
     end
 
     def validate_method_definition(method_def, type_name:)
-      method_def.types.each do |method_type|
+      method_def.overloads.each do |overload|
+        method_type = overload.method_type
         unless method_type.type_params.empty?
           loc = method_type.location&.aref(:type_params)
 

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "2.8.4"
+  VERSION = "3.0.0.dev.1"
 end

data/lib/rbs/writer.rb

@@ -39,21 +39,27 @@ module RBS
       end
     end
 
+    def format_annotation(annotation)
+      string = annotation.string
+      case
+      when string !~ /\}/
+        "%a{#{string}}"
+      when string !~ /\)/
+        "%a(#{string})"
+      when string !~ /\]/
+        "%a[#{string}]"
+      when string !~ /\>/
+        "%a<#{string}>"
+      when string !~ /\|/
+        "%a|#{string}|"
+      else
+        raise
+      end
+    end
+
     def write_annotation(annotations)
       annotations.each do |annotation|
-        string = annotation.string
-        case
-        when string !~ /\}/
-          puts "%a{#{string}}"
-        when string !~ /\)/
-          puts "%a(#{string})"
-        when string !~ /\]/
-          puts "%a[#{string}]"
-        when string !~ /\>/
-          puts "%a<#{string}>"
-        when string !~ /\|/
-          puts "%a|#{string}|"
-        end
+        puts format_annotation(annotation)
       end
     end
 
@@ -289,17 +295,20 @@ module RBS
 
       string << prefix
 
-      member.types.each.with_index do |type, index|
+      member.overloads.each.with_index do |overload, index|
         if index > 0
           string << padding
           string << "|"
         end
 
-        string << " #{type}\n"
+        overload.annotations.each do |annotation|
+          string << " #{format_annotation(annotation)}"
+        end
+        string << " #{overload.method_type}\n"
       end
 
-      if member.overload
-        if member.types.size > 0
+      if member.overloading?
+        if member.overloads.size > 0
           string << padding
           string << "|"
         end

data/lib/rbs.rb

@@ -39,6 +39,7 @@ require "rbs/prototype/helpers"
 require "rbs/prototype/rbi"
 require "rbs/prototype/rb"
 require "rbs/prototype/runtime"
+require "rbs/prototype/node_usage"
 require "rbs/type_name_resolver"
 require "rbs/environment_walker"
 require "rbs/vendorer"

data/lib/rdoc_plugin/parser.rb

@@ -74,7 +74,7 @@ module RBS
         method = RDoc::AnyMethod.new(nil, decl.name.to_s)
         method.singleton = decl.singleton?
         method.visibility = decl.visibility
-        method.call_seq = decl.types.map { |type| "#{decl.name.to_s}#{type.to_s}" }.join("\n")
+        method.call_seq = decl.overloads.map {|overload| "#{decl.name.to_s}#{overload.method_type.to_s}" }.join("\n")
         if loc = decl.location
           method.start_collecting_tokens
           method.add_token({ line_no: 1, char_no: 1, kind: :on_comment, text: "# File #{@top_level.relative_name}, line(s) #{loc.start_line}:#{loc.end_line}\n" })

data/rbs.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin|steep)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin)/}) }
   end
   spec.extensions = %w{ext/rbs_extension/extconf.rb}
 

data/schema/members.json

@@ -14,10 +14,21 @@
         "kind": {
           "enum": ["instance", "singleton", "singleton_instance"]
         },
-        "types": {
+        "overloads": {
           "type": "array",
           "items": {
-            "$ref": "methodType.json"
+            "type": "object",
+            "properties": {
+              "annotations": {
+                "type": "array",
+                "items": {
+                  "$ref": "annotation.json"
+                }
+              },
+              "method_type": {
+                "$ref": "methodType.json"
+              }
+            }
           }
         },
         "comment": {
@@ -29,23 +40,17 @@
             "$ref": "annotation.json"
           }
         },
-        "attributes": {
-          "type": "array",
-          "items": {
-            "enum": ["incompatible"]
-          }
-        },
         "location": {
           "$ref": "location.json"
         },
-        "overload": {
+        "overloading": {
           "type": "boolean"
         },
         "visibility": {
           "enum": ["public", "private", null]
         }
       },
-      "required": ["member", "name", "kind", "types", "comment", "annotations", "location", "visibility"]
+      "required": ["member", "name", "kind", "overloads", "comment", "annotations", "location", "visibility", "overloading"]
     },
     "variable": {
       "title": "Declaration for instance variables and class variables",

data/sig/collection/config/lockfile.rbs

@@ -0,0 +1,80 @@
+module RBS
+  module Collection
+    class Config
+      # Lockfile represents the `rbs_collection.lock.yaml`, that contains configurations and *resolved* gems with their sources
+      #
+      class Lockfile
+        # Data structure stored in `rbs_collection.lock.yaml`
+        #
+        type lockfile_data = {
+          "sources" => Array[Sources::Git::source_entry]?,   # null if empty
+          "path" => String,
+          "gems" => Array[library_data]?,         # null if empty
+          "gemfile_lock_path" => String?          # gemfile_lock_path is optional because older versions doesn't have it
+        }
+
+        type library_data = {
+          'name' => String,
+          'version' => String,
+          'source' => Sources::source_entry
+        }
+
+        # In-memory data structure that represents a library
+        #
+        type library = {
+          name: String,
+          version: String,
+          source: Sources::t
+        }
+
+        attr_reader lockfile_path: Pathname
+
+        # Path of the directory where lockfile is saved in
+        #
+        # `lockfile_path.parent`
+        #
+        attr_reader lockfile_dir: Pathname
+
+        # Relative to lockfile_dir
+        #
+        attr_reader path: Pathname
+
+        # Relative to lockfile_dir
+        #
+        attr_reader gemfile_lock_path: Pathname?
+
+        attr_reader sources: Hash[String, Sources::Git]
+
+        attr_reader gems: Hash[String, library]
+
+        def initialize: (lockfile_path: Pathname, path: Pathname, gemfile_lock_path: Pathname?) -> void
+
+        # `lockfile_dir` + `path`
+        #
+        def fullpath: () -> Pathname
+
+        # `lockfile_dir` + `gemfile_lock_path`
+        #
+        %a{pure} def gemfile_lock_fullpath: () -> Pathname?
+
+        def to_lockfile: () -> lockfile_data
+
+        def each_source: () { (Sources::t) -> void } -> void
+                       | () -> Enumerator[Sources::t, void]
+
+        def self.from_lockfile: (lockfile_path: Pathname, data: lockfile_data) -> Lockfile
+
+        # Validates if directories are set up correctly
+        #
+        # * Ensures if `path` is a directory
+        # * Ensures if `git` sources are set up correctly
+        #
+        def check_rbs_availability!: () -> void
+
+        private
+
+        def library_data: (library) -> library_data
+      end
+    end
+  end
+end