rbs-relaxed 3.9.0.1

data/lib/rbs/parser_aux.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "parser/lex_result"
+require_relative "parser/token"
+
+module RBS
+  class Parser
+    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, require_eof)
+    end
+
+    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, require_eof)
+    end
+
+    def self.parse_signature(source)
+      buf = buffer(source)
+
+      resolved = magic_comment(buf)
+      start_pos =
+        if resolved
+          (resolved.location || raise).end_pos
+        else
+          0
+        end
+      dirs, decls = _parse_signature(buf, start_pos, buf.last_position)
+
+      if resolved
+        dirs = dirs.dup if dirs.frozen?
+        dirs.unshift(resolved)
+      end
+
+      [buf, dirs, decls]
+    end
+
+    def self.magic_comment(buf)
+      start_pos = 0
+
+      while true
+        case
+        when match = /\A#\s*(?<keyword>resolve-type-names)\s*(?<colon>:)\s+(?<value>true|false)$/.match(buf.content, start_pos)
+          value = match[:value] or raise
+
+          kw_offset = match.offset(:keyword) #: [Integer, Integer]
+          colon_offset = match.offset(:colon) #: [Integer, Integer]
+          value_offset = match.offset(:value) #: [Integer, Integer]
+
+          location = Location.new(buf, kw_offset[0], value_offset[1])
+          location.add_required_child(:keyword, kw_offset[0]...kw_offset[1])
+          location.add_required_child(:colon, colon_offset[0]...colon_offset[1])
+          location.add_required_child(:value, value_offset[0]...value_offset[1])
+
+          return AST::Directives::ResolveTypeNames.new(value: value == "true", location: location)
+        else
+          return
+        end
+      end
+    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)
+      case source
+      when String
+        Buffer.new(content: source, name: "a.rbs")
+      when Buffer
+        source
+      end
+    end
+
+    KEYWORDS = %w(
+      bool
+      bot
+      class
+      instance
+      interface
+      nil
+      self
+      singleton
+      top
+      void
+      type
+      unchecked
+      in
+      out
+      end
+      def
+      include
+      extend
+      prepend
+      alias
+      module
+      attr_reader
+      attr_writer
+      attr_accessor
+      public
+      private
+      untyped
+      true
+      false
+      ).each_with_object({}) do |keyword, hash| #$ Hash[String, bot]
+        hash[keyword] = _ = nil
+      end
+  end
+end

data/lib/rbs/prototype/helpers.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RBS
+  module Prototype
+    module Helpers
+      private
+
+      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)
+
+        # @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
+
+          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 || []
+
+              # @type var keywords: node?
+              positionals, keywords = if keyword_hash?(array_content.last)
+                                        [array_content.take(array_content.size - 1), array_content.last]
+                                      else
+                                        [array_content, nil]
+                                      end
+
+              if (diff = positionals.size - function.required_positionals.size) > 0
+                diff.times do
+                  function.required_positionals << Types::Function::Param.new(
+                    type: untyped,
+                    name: nil
+                  )
+                end
+              end
+
+              if keywords
+                keywords.children[0].children.each_slice(2) do |key_node, value_node|
+                  if key_node
+                    key = key_node.children[0]
+                    function.required_keywords[key] ||=
+                      Types::Function::Param.new(
+                        type: untyped,
+                        name: nil
+                      )
+                  end
+                end
+              end
+            end
+          else
+            function = Types::UntypedFunction.new(return_type: untyped)
+          end
+
+
+          Types::Block.new(required: required, type: function, self_type: nil)
+        end
+      end
+
+      def each_child(node, &block)
+        each_node node.children, &block
+      end
+
+      def each_node(nodes)
+        nodes.each do |child|
+          if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
+            yield child
+          end
+        end
+      end
+
+      def any_node?(node, nodes: [], &block)
+        if yield(node)
+          nodes << node
+        end
+
+        each_child node do |child|
+          any_node? child, nodes: nodes, &block
+        end
+
+        nodes.empty? ? nil : nodes
+      end
+
+      def keyword_hash?(node)
+        if node && node.type == :HASH
+          node.children[0].children.compact.each_slice(2).all? {|key, _|
+            symbol_literal_node?(key)
+          }
+        else
+          false
+        end
+      end
+
+      # NOTE: args_node may be a nil by a bug
+      #       https://bugs.ruby-lang.org/issues/17495
+      def args_from_node(args_node)
+        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
+    end
+  end
+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