rbs 2.8.4 → 3.8.1

data/lib/rbs/locator.rb

@@ -2,21 +2,24 @@
 
 module RBS
   class Locator
-    attr_reader :decls
+    attr_reader :decls, :dirs, :buffer
 
-    def initialize(decls:)
+    def initialize(buffer:, dirs:, decls:)
+      @buffer = buffer
+      @dirs = dirs
       @decls = decls
     end
 
-    def buffer
-      decls[0].location&.buffer or raise
-    end
-
     def find(line:, column:)
       pos = buffer.loc_to_pos([line, column])
 
+      dirs.each do |dir|
+        array = [] #: Array[component]
+        find_in_directive(pos, dir, array) and return array
+      end
+
       decls.each do |decl|
-        array = []
+        array = [] #: Array[component]
         find_in_decl(pos, decl: decl, array: array) and return array
       end
 
@@ -36,6 +39,22 @@ module RBS
       end
     end
 
+    def find_in_directive(pos, dir, array)
+      if test_loc(pos, location: dir.location)
+        array.unshift(dir)
+
+        dir.clauses.each do |clause|
+          if test_loc(pos, location: clause.location)
+            array.unshift(clause)
+            find_in_loc(pos, location: clause.location, array: array)
+            return true
+          end
+        end
+      end
+
+      false
+    end
+
     def find_in_decl(pos, decl:, array:)
       if test_loc(pos, location: decl.location)
         array.unshift(decl)
@@ -95,7 +114,7 @@ module RBS
         when AST::Declarations::Constant, AST::Declarations::Global
           find_in_type(pos, array: array, type: decl.type) and return true
 
-        when AST::Declarations::Alias
+        when AST::Declarations::TypeAlias
           find_in_type(pos, array: array, type: decl.type) and return true
         end
 
@@ -113,8 +132,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
@@ -152,13 +171,16 @@ module RBS
       if test_loc(pos, location: type_param.location)
         array.unshift(type_param)
 
-        if upper_bound = type_param.upper_bound
-          find_in_type(pos, type: upper_bound, array: array) or
-            find_in_loc(pos, location: type_param.location, array: array)
-        else
-          find_in_loc(pos, location: type_param.location, array: array)
+        if upper_bound = type_param.upper_bound_type
+          find_in_type(pos, type: upper_bound, array: array) and return true
         end
 
+        if default_type = type_param.default_type
+          find_in_type(pos, type: default_type, array: array) and return true
+        end
+
+        find_in_loc(pos, location: type_param.location, array: array)
+
         true
       else
         false

data/lib/rbs/method_type.rb

@@ -86,6 +86,9 @@ module RBS
         type.each_type(&block)
         self.block&.yield_self do |b|
           b.type.each_type(&block)
+          if b.self_type
+            yield b.self_type
+          end
         end
       else
         enum_for :each_type
@@ -114,5 +117,25 @@ module RBS
     def type_param_names
       type_params.map(&:name)
     end
+
+    def has_self_type?
+      each_type.any? {|type| type.has_self_type? }
+    end
+
+    def has_classish_type?
+      each_type.any? {|type| type.has_classish_type? }
+    end
+
+    def with_nonreturn_void?
+      if type.with_nonreturn_void?
+        true
+      else
+        if block = block()
+          block.type.with_nonreturn_void? || block.self_type&.with_nonreturn_void? || false
+        else
+          false
+        end
+      end
+    end
   end
 end

data/lib/rbs/namespace.rb

@@ -119,6 +119,7 @@ end
 
 module Kernel
   def Namespace(name)
+    warn "Kernel#Namespace() is deprecated. Use RBS::Namespace.parse instead.", category: :deprecated
     RBS::Namespace.parse(name)
   end
 end

data/lib/rbs/parser/lex_result.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RBS
+  class Parser
+    class LexResult
+      attr_reader :buffer
+      attr_reader :value
+
+      def initialize(buffer:, value:)
+        @buffer = buffer
+        @value = value
+      end
+    end
+  end
+end

data/lib/rbs/parser/token.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RBS
+  class Parser
+    class Token
+      attr_reader :type
+      attr_reader :location
+
+      def initialize(type:, location:)
+        @type = type
+        @location = location
+      end
+
+      def value
+        @location.source
+      end
+
+      def comment?
+        @type == :tCOMMENT || @type == :tLINECOMMENT
+      end
+    end
+  end
+end

data/lib/rbs/parser_aux.rb

@@ -1,20 +1,34 @@
 # frozen_string_literal: true
 
+require_relative "parser/lex_result"
+require_relative "parser/token"
+
 module RBS
   class Parser
-    def self.parse_type(source, line: nil, column: nil, range: nil, variables: [])
+    def self.parse_type(source, range: 0..., variables: [], require_eof: false)
       buf = buffer(source)
-      _parse_type(buf, range&.begin || 0, range&.end || buf.last_position, variables, range.nil?)
+      _parse_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof)
     end
 
-    def self.parse_method_type(source, line: nil, column: nil, range: nil, variables: [])
+    def self.parse_method_type(source, range: 0..., variables: [], require_eof: false)
       buf = buffer(source)
-      _parse_method_type(buf, range&.begin || 0, range&.end || buf.last_position, variables, range.nil?)
+      _parse_method_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof)
     end
 
-    def self.parse_signature(source, line: nil, column: nil)
+    def self.parse_signature(source)
       buf = buffer(source)
-      _parse_signature(buf, buf.last_position)
+      dirs, decls = _parse_signature(buf, buf.last_position)
+
+      [buf, dirs, decls]
+    end
+
+    def self.lex(source)
+      buf = buffer(source)
+      list = _lex(buf, buf.last_position)
+      value = list.map do |type, location|
+        Token.new(type: type, location: location)
+      end
+      LexResult.new(buffer: buf, value: value)
     end
 
     def self.buffer(source)
@@ -26,11 +40,6 @@ module RBS
       end
     end
 
-    autoload :SyntaxError, "rbs/parser_compat/syntax_error"
-    autoload :SemanticsError, "rbs/parser_compat/semantics_error"
-    autoload :LexerError, "rbs/parser_compat/lexer_error"
-    autoload :LocatedValue, "rbs/parser_compat/located_value"
-
     KEYWORDS = %w(
       bool
       bot
@@ -61,8 +70,8 @@ module RBS
       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

data/lib/rbs/prototype/helpers.rb

@@ -7,26 +7,38 @@ 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
 
-        method_block = nil
+        if yields || block_var
+          required = true
 
-        if block
-          method_block = Types::Block.new(
-            required: false,
-            type: Types::Function.empty(untyped),
-            self_type: nil
-          )
-        end
+          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 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 _rest == :* && block_var == :&
+            # ... is given
+            required = false
+          end
+
+          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 yields
+            function = Types::Function.empty(untyped)
 
             yields.each do |yield_node|
               array_content = yield_node.children[0]&.children&.compact || []
@@ -38,9 +50,9 @@ module RBS
                                         [array_content, nil]
                                       end
 
-              if (diff = positionals.size - method_block.type.required_positionals.size) > 0
+              if (diff = positionals.size - function.required_positionals.size) > 0
                 diff.times do
-                  method_block.type.required_positionals << Types::Function::Param.new(
+                  function.required_positionals << Types::Function::Param.new(
                     type: untyped,
                     name: nil
                   )
@@ -51,7 +63,7 @@ module RBS
                 keywords.children[0].children.each_slice(2) do |key_node, value_node|
                   if key_node
                     key = key_node.children[0]
-                    method_block.type.required_keywords[key] ||=
+                    function.required_keywords[key] ||=
                       Types::Function::Param.new(
                         type: untyped,
                         name: nil
@@ -60,10 +72,13 @@ module RBS
                 end
               end
             end
+          else
+            function = Types::UntypedFunction.new(return_type: untyped)
           end
-        end
 
-        method_block
+
+          Types::Block.new(required: required, type: function, self_type: nil)
+        end
       end
 
       def each_child(node, &block)
@@ -93,7 +108,7 @@ module RBS
       def keyword_hash?(node)
         if node && node.type == :HASH
           node.children[0].children.compact.each_slice(2).all? {|key, _|
-            key.type == :LIT && key.children[0].is_a?(Symbol)
+            symbol_literal_node?(key)
           }
         else
           false
@@ -106,6 +121,17 @@ module RBS
         args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
       end
 
+      def symbol_literal_node?(node)
+        case node.type
+        when :LIT
+          if node.children[0].is_a?(Symbol)
+            node.children[0]
+          end
+        when :SYM
+          node.children[0]
+        end
+      end
+
       def untyped
         @untyped ||= Types::Bases::Any.new(location: nil)
       end

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