rbs 4.1.0.pre.2-java

data/lib/rbs/location_aux.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module RBS
+  class Location
+    def inspect
+      rks = each_required_key.to_a
+      ops = each_optional_key.to_a.map {|x| "?#{x}" }
+      src = if source.length <= 1
+        source.inspect
+      else
+        source.each_line.first&.chomp&.inspect
+      end
+      "#<#{self.class}:#{self.__id__} buffer=#{buffer.name}, start=#{start_line}:#{start_column}, pos=#{start_pos}...#{end_pos}, children=#{(rks + ops).join(",")} source=#{src}>"
+    end
+
+    def self.new(buffer_ = nil, start_pos_ = nil, end_pos_ = nil, buffer: nil, start_pos: nil, end_pos: nil)
+      __skip__ =
+        begin
+          if buffer && start_pos && end_pos
+            super(buffer, start_pos, end_pos)
+          else
+            super(buffer_, start_pos_, end_pos_)
+          end
+        end
+    end
+
+    alias aref []
+
+    WithChildren = self
+
+    def start_pos
+      buffer.absolute_position(_start_pos) || raise
+    end
+
+    def end_pos
+      buffer.absolute_position(_end_pos) || raise
+    end
+
+    def name
+      buffer.name
+    end
+
+    def start_line
+      start_loc[0]
+    end
+
+    def start_column
+      start_loc[1]
+    end
+
+    def end_line
+      end_loc[0]
+    end
+
+    def end_column
+      end_loc[1]
+    end
+
+    def start_loc
+      @start_loc ||= buffer.top_buffer.pos_to_loc(start_pos)
+    end
+
+    def end_loc
+      @end_loc ||= buffer.top_buffer.pos_to_loc(end_pos)
+    end
+
+    def range
+      @range ||= start_pos...end_pos
+    end
+
+    def source
+      @source ||= (buffer.top_buffer.content[range] || raise)
+    end
+
+    def to_s
+      "#{name || "-"}:#{start_line}:#{start_column}...#{end_line}:#{end_column}"
+    end
+
+    def ==(other)
+      other.is_a?(Location) &&
+        other.buffer == buffer &&
+        other.start_pos == start_pos &&
+        other.end_pos == end_pos
+    end
+
+    def to_json(state = nil)
+      {
+        start: {
+          line: start_line,
+          column: start_column
+        },
+        end: {
+          line: end_line,
+          column: end_column
+        },
+        buffer: {
+          name: name&.to_s
+        }
+      }.to_json(state)
+    end
+
+    def self.to_string(location, default: "*:*:*...*:*")
+      location&.to_s || default
+    end
+
+    def add_required_child(name, range)
+      _add_required_child(name, range.begin, range.end)
+    end
+
+    def add_optional_child(name, range)
+      if range
+        _add_optional_child(name, range.begin, range.end)
+      else
+        _add_optional_no_child(name);
+      end
+    end
+
+    def each_optional_key(&block)
+      if block
+        _optional_keys.uniq.each(&block)
+      else
+        enum_for(:each_optional_key)
+      end
+    end
+
+    def each_required_key(&block)
+      if block
+        _required_keys.uniq.each(&block)
+      else
+        enum_for(:each_required_key)
+      end
+    end
+
+    def key?(name)
+      optional_key?(name) || required_key?(name)
+    end
+
+    def optional_key?(name)
+      _optional_keys.include?(name)
+    end
+
+    def required_key?(name)
+      _required_keys.include?(name)
+    end
+
+    def local_location
+      loc = Location.new(buffer.detach, _start_pos, _end_pos)
+
+      each_optional_key do |key|
+        value = self[key]
+        if value
+          loc.add_optional_child(key, value._start_pos...value._end_pos)
+        else
+          loc.add_optional_child(key, nil)
+        end
+      end
+
+      each_required_key do |key|
+        value = self[key] or raise
+        loc.add_required_child(key, value._start_pos...value._end_pos)
+      end
+
+      loc #: self
+    end
+
+    def local_source
+      local_location.source
+    end
+  end
+end

data/lib/rbs/locator.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module RBS
+  class Locator
+    attr_reader :decls, :dirs, :buffer
+
+    def initialize(buffer:, dirs:, decls:)
+      @buffer = buffer
+      @dirs = dirs
+      @decls = decls
+    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[component]
+        find_in_decl(pos, decl: decl, array: array) and return array
+      end
+
+      []
+    end
+
+    def find2(line:, column:)
+      path = find(line: line, column: column)
+
+      return if path.empty?
+
+      hd, *tl = path
+      if hd.is_a?(Symbol)
+        [hd, tl]
+      else
+        [nil, path]
+      end
+    end
+
+    def find_in_directive(pos, dir, array)
+      return false unless dir.is_a?(AST::Directives::Use)
+
+      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)
+
+        case decl
+        when AST::Declarations::Class
+          decl.type_params.each do |param|
+            find_in_type_param(pos, type_param: param, array: array) and return true
+          end
+
+          if super_class = decl.super_class
+            if test_loc(pos, location: super_class.location)
+              array.unshift(super_class)
+              find_in_loc(pos, array: array, location: super_class.location)
+              return true
+            end
+          end
+
+          decl.each_decl do |decl_|
+            find_in_decl(pos, decl: decl_, array: array) and return true
+          end
+
+          decl.each_member do |member|
+            find_in_member(pos, array: array, member: member) and return true
+          end
+
+        when AST::Declarations::Module
+          decl.type_params.each do |param|
+            find_in_type_param(pos, type_param: param, array: array) and return true
+          end
+
+          decl.self_types.each do |self_type|
+            if test_loc(pos, location: self_type.location)
+              array.unshift(self_type)
+              find_in_loc(pos, array: array, location: self_type.location)
+              return true
+            end
+          end
+
+          decl.each_decl do |decl_|
+            find_in_decl(pos, decl: decl_, array: array) and return true
+          end
+
+          decl.each_member do |member|
+            find_in_member(pos, array: array, member: member) and return true
+          end
+
+        when AST::Declarations::Interface
+          decl.type_params.each do |param|
+            find_in_type_param(pos, type_param: param, array: array) and return true
+          end
+
+          decl.members.each do |member|
+            find_in_member(pos, array: array, member: member) and return true
+          end
+
+        when AST::Declarations::Constant, AST::Declarations::Global
+          find_in_type(pos, array: array, type: decl.type) and return true
+
+        when AST::Declarations::TypeAlias
+          find_in_type(pos, array: array, type: decl.type) and return true
+        end
+
+        find_in_loc(pos, location: decl.location, array: array)
+
+        true
+      else
+        false
+      end
+    end
+
+    def find_in_member(pos, member:, array:)
+      if test_loc(pos, location: member.location)
+        array.unshift(member)
+
+        case member
+        when AST::Members::MethodDefinition
+          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
+        when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+          find_in_type(pos, array: array, type: member.type) and return true
+        end
+
+        find_in_loc(pos, location: member.location, array: array)
+
+        true
+      else
+        false
+      end
+    end
+
+    def find_in_method_type(pos, method_type:, array:)
+      if test_loc(pos, location: method_type.location)
+        array.unshift(method_type)
+
+        method_type.type_params.each do |param|
+          find_in_type_param(pos, type_param: param, array: array) and return true
+        end
+
+        method_type.each_type do |type|
+          find_in_type(pos, array: array, type: type) and break
+        end
+
+        true
+      else
+        false
+      end
+    end
+
+    def find_in_type_param(pos, type_param:, array:)
+      if test_loc(pos, location: type_param.location)
+        array.unshift(type_param)
+
+        if upper_bound = type_param.upper_bound_type
+          find_in_type(pos, type: upper_bound, array: array) and return true
+        end
+
+        if lower_bound = type_param.lower_bound_type
+          find_in_type(pos, type: lower_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
+      end
+    end
+
+    def find_in_type(pos, type:, array:)
+      if test_loc(pos, location: type.location)
+        array.unshift(type)
+
+        type.each_type do |type_|
+          find_in_type(pos, array: array, type: type_) and return true
+        end
+
+        find_in_loc(pos, array: array, location: type.location)
+
+        true
+      else
+        false
+      end
+    end
+
+    def find_in_loc(pos, location:, array:)
+      if test_loc(pos, location: location)
+        if location.is_a?(Location)
+          location.each_optional_key do |key|
+            if loc = location[key]
+              if loc.range === pos
+                array.unshift(key)
+                return true
+              end
+            end
+          end
+
+          location.each_required_key do |key|
+            loc = location[key] or raise
+            if loc.range === pos
+              array.unshift(key)
+              return true
+            end
+          end
+        end
+
+        true
+      else
+        false
+      end
+    end
+
+    def test_loc(pos, location:)
+      if location
+        location.start_pos <= pos && pos <= location.end_pos
+      else
+        false
+      end
+    end
+  end
+end

data/lib/rbs/method_type.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RBS
+  class MethodType
+    attr_reader :type_params
+    attr_reader :type
+    attr_reader :block
+    attr_reader :location
+
+    def initialize(type_params:, type:, block:, location:)
+      @type_params = type_params
+      @type = type
+      @block = block
+      @location = location
+    end
+
+    def ==(other)
+      other.is_a?(MethodType) &&
+        other.type_params == type_params &&
+        other.type == type &&
+        other.block == block
+    end
+
+    def to_json(state = nil)
+      {
+        type_params: type_params,
+        type: type,
+        block: block,
+        location: location
+      }.to_json(state)
+    end
+
+    def sub(s)
+      sub = s.without(*type_param_names)
+
+      return self if sub.empty?
+
+      self.class.new(
+        type_params: type_params.map do |param|
+          param.map_type do |bound|
+            bound.map_type {|ty| ty.sub(sub) }
+          end
+        end,
+        type: type.sub(sub),
+        block: block&.sub(sub),
+        location: location
+      )
+    end
+
+    def update(type_params: self.type_params, type: self.type, block: self.block, location: self.location)
+      self.class.new(
+        type_params: type_params,
+        type: type,
+        block: block,
+        location: location
+      )
+    end
+
+    def free_variables(set = Set.new)
+      type.free_variables(set)
+      block&.type&.free_variables(set)
+      set.subtract(type_param_names)
+    end
+
+    def map_type(&block)
+      self.class.new(
+        type_params: type_params,
+        type: type.map_type(&block),
+        block: self.block&.map_type(&block),
+        location: location
+      )
+    end
+
+    def map_type_bound(&block)
+      if type_params.empty?
+        self
+      else
+        self.update(
+          type_params: type_params.map {|param|
+            param.map_type(&block)
+          }
+        )
+      end
+    end
+
+    def each_type(&block)
+      if block
+        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
+      end
+    end
+
+    def to_s
+      block_self_binding = Types::SelfTypeBindingHelper.self_type_binding_to_s(block&.self_type)
+
+      s = case
+          when (b = block) && b.required
+            "(#{type.param_to_s}) { (#{b.type.param_to_s}) #{block_self_binding}-> #{b.type.return_to_s} } -> #{type.return_to_s}"
+          when b = block
+            "(#{type.param_to_s}) ?{ (#{b.type.param_to_s}) #{block_self_binding}-> #{b.type.return_to_s} } -> #{type.return_to_s}"
+          else
+            "(#{type.param_to_s}) -> #{type.return_to_s}"
+          end
+
+      if type_params.empty?
+        s
+      else
+        "[#{type_params.join(", ")}] #{s}"
+      end
+    end
+
+    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? # steep:ignore DeprecatedReference
+        true
+      else
+        if block = block()
+          block.type.with_nonreturn_void? || # steep:ignore DeprecatedReference
+            block.self_type&.with_nonreturn_void? || # steep:ignore DeprecatedReference
+            false
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rbs/namespace.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RBS
+  class Namespace
+    attr_reader :path
+
+    def initialize(path:, absolute:)
+      @path = path
+      @absolute = absolute ? true : false
+    end
+
+    # Process-wide flyweight cache. Two tries (one per `absolute` flag)
+    # keyed on path Symbols, with the cached Namespace stored under the
+    # `INTERN_LEAF` sentinel at each path's terminal node.
+    @intern_mutex = Mutex.new
+    @intern_trie_absolute = {}
+    @intern_trie_relative = {}
+    INTERN_LEAF = Module.new
+
+    # Returns a canonical `Namespace` instance for the given `path` /
+    # `absolute` pair. Repeated calls with structurally equal arguments
+    # return the same object, so callers can rely on `equal?` for fast
+    # equality. The path Array is duplicated and frozen on insert.
+    def self.[](path, absolute)
+      absolute = absolute ? true : false
+
+      # Lock-free fast path.
+      node = absolute ? @intern_trie_absolute : @intern_trie_relative
+      path.each do |sym|
+        node = node[sym]
+        break unless node
+      end
+      if node && (cached = node[INTERN_LEAF])
+        return cached
+      end
+
+      @intern_mutex.synchronize do
+        node = absolute ? @intern_trie_absolute : @intern_trie_relative
+        path.each { |sym| node = (node[sym] ||= {}) }
+        node[INTERN_LEAF] ||= begin
+          frozen_path = path.frozen? ? path : path.dup.freeze
+          new(path: frozen_path, absolute: absolute)
+        end
+      end
+    end
+
+    def self.empty
+      @empty ||= self[[], false]
+    end
+
+    def self.root
+      @root ||= self[[], true]
+    end
+
+    def +(other)
+      if other.absolute?
+        other
+      else
+        Namespace[path + other.path, absolute?]
+      end
+    end
+
+    def append(component)
+      Namespace[path + [component], absolute?]
+    end
+
+    def parent
+      @parent ||= begin
+        raise "Parent with empty namespace" if empty?
+        Namespace[path.take(path.size - 1), absolute?]
+      end
+    end
+
+    def absolute?
+      @absolute
+    end
+
+    def relative?
+      !absolute?
+    end
+
+    def absolute!
+      Namespace[path, true]
+    end
+
+    def relative!
+      Namespace[path, false]
+    end
+
+    def empty?
+      path.empty?
+    end
+
+    def ==(other)
+      return true if equal?(other)
+      other.is_a?(Namespace) && other.path == path && other.absolute? == absolute?
+    end
+
+    alias eql? ==
+
+    def hash
+      @hash ||= path.hash ^ absolute?.hash
+    end
+
+    def split
+      last = path.last or return
+      parent = self.parent
+      [parent, last]
+    end
+
+    def to_s
+      if empty?
+        absolute? ? "::" : ""
+      else
+        s = path.join("::")
+        absolute? ? "::#{s}::" : "#{s}::"
+      end
+    end
+
+    def to_type_name
+      parent, name = split
+
+      raise unless name
+      raise unless parent
+
+      TypeName[parent, name]
+    end
+
+    def self.parse(string)
+      if string.start_with?("::")
+        self[string.split("::").drop(1).map(&:to_sym), true]
+      else
+        self[string.split("::").map(&:to_sym), false]
+      end
+    end
+
+    def ascend
+      if block_given?
+        current = self
+
+        until current.empty?
+          yield current
+          current = _ = current.parent
+        end
+
+        yield current
+
+        self
+      else
+        enum_for(:ascend)
+      end
+    end
+  end
+end