rbs 4.1.0.pre.2-java

data/lib/rbs/ast/type_param.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    class TypeParam
+      attr_reader :name, :variance, :location, :upper_bound_type, :lower_bound_type, :default_type
+
+      def initialize(name:, variance:, upper_bound:, lower_bound:, location:, default_type: nil, unchecked: false)
+        @name = name
+        @variance = variance
+        @upper_bound_type = upper_bound
+        @lower_bound_type = lower_bound
+        @location = location
+        @default_type = default_type
+        @unchecked = unchecked
+      end
+
+      def upper_bound
+        case upper_bound_type
+        when Types::ClassInstance, Types::ClassSingleton, Types::Interface
+          upper_bound_type
+        end
+      end
+
+      def lower_bound
+        case lower_bound_type
+        when Types::ClassInstance, Types::ClassSingleton, Types::Interface
+          lower_bound_type
+        end
+      end
+
+      def unchecked!(value = true)
+        @unchecked = value ? true : false
+        self
+      end
+
+      def unchecked?
+        @unchecked
+      end
+
+      def ==(other)
+        other.is_a?(TypeParam) &&
+          other.name == name &&
+          other.variance == variance &&
+          other.upper_bound_type == upper_bound_type &&
+          other.lower_bound_type == lower_bound_type &&
+          other.default_type == default_type &&
+          other.unchecked? == unchecked?
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound_type.hash ^ lower_bound_type.hash ^ unchecked?.hash ^ default_type.hash
+      end
+
+      def to_json(state = JSON::State.new)
+        {
+          name: name,
+          variance: variance,
+          unchecked: unchecked?,
+          location: location,
+          upper_bound: upper_bound_type,
+          lower_bound: lower_bound_type,
+          default_type: default_type
+        }.to_json(state)
+      end
+
+      def map_type(&block)
+        if b = upper_bound_type
+          _upper_bound_type = yield(b)
+        end
+
+        if b = lower_bound_type
+          _lower_bound_type = yield(b)
+        end
+
+        if dt = default_type
+          _default_type = yield(dt)
+        end
+
+        TypeParam.new(
+          name: name,
+          variance: variance,
+          upper_bound: _upper_bound_type,
+          lower_bound: _lower_bound_type,
+          location: location,
+          default_type: _default_type
+        ).unchecked!(unchecked?)
+      end
+
+      def self.resolve_variables(params)
+        return if params.empty?
+
+        vars = Set.new(params.map(&:name))
+
+        params.map! do |param|
+          param.map_type {|bound| _ = subst_var(vars, bound) }
+        end
+      end
+
+      def self.subst_var(vars, type)
+        case type
+        when Types::ClassInstance
+          namespace = type.name.namespace
+          if namespace.relative? && namespace.empty? && vars.member?(type.name.name)
+            return Types::Variable.new(name: type.name.name, location: type.location)
+          end
+        end
+
+        type.map_type {|t| subst_var(vars, t) }
+      end
+
+      def self.rename(params, new_names:)
+        raise unless params.size == new_names.size
+
+        subst = Substitution.build(new_names, Types::Variable.build(new_names))
+
+        params.map.with_index do |param, index|
+          new_name = new_names[index]
+
+          TypeParam.new(
+            name: new_name,
+            variance: param.variance,
+            upper_bound: param.upper_bound_type&.map_type {|type| type.sub(subst) },
+            lower_bound: param.lower_bound_type&.map_type {|type| type.sub(subst) },
+            location: param.location,
+            default_type: param.default_type&.map_type {|type| type.sub(subst) }
+          ).unchecked!(param.unchecked?)
+        end
+      end
+
+      def to_s
+        s = +""
+
+        if unchecked?
+          s << "unchecked "
+        end
+
+        case variance
+        when :invariant
+          # nop
+        when :covariant
+          s << "out "
+        when :contravariant
+          s << "in "
+        end
+
+        s << name.to_s
+
+        if type = upper_bound_type
+          s << " < #{type}"
+        end
+
+        if type = lower_bound_type
+          s << " > #{type}"
+        end
+
+        if dt = default_type
+          s << " = #{dt}"
+        end
+
+        s
+      end
+
+      def self.application(params, args)
+        if params.empty?
+          return nil
+        end
+
+        optional_params, required_params = params.partition {|param| param.default_type }
+
+        param_subst = Substitution.new()
+        app_subst = Substitution.new()
+
+        required_params.zip(args.take(required_params.size)).each do |param, arg|
+          arg ||= Types::Bases::Any.new(location: nil)
+          param_subst.add(from: param.name, to: arg)
+          app_subst.add(from: param.name, to: arg)
+        end
+
+        optional_params.each do |param|
+          param_subst.add(from: param.name, to: Types::Bases::Any.new(location: nil))
+        end
+
+        optional_params.zip(args.drop(required_params.size)).each do |param, arg|
+          if arg
+            app_subst.add(from: param.name, to: arg)
+          else
+            param.default_type or raise
+            app_subst.add(from: param.name, to: param.default_type.sub(param_subst))
+          end
+        end
+
+        app_subst
+      end
+
+      def self.normalize_args(params, args)
+        app = application(params, args) or return args
+
+        min_count = params.count { _1.default_type.nil? }
+        unless min_count <= args.size && args.size <= params.size
+          return args
+        end
+
+        params.zip(args).filter_map do |param, arg|
+          if arg
+            arg
+          else
+            if param.default_type
+              param.default_type.sub(app)
+            else
+              Types::Bases::Any.new(location: nil)
+            end
+          end
+        end
+      end
+
+      def self.validate(type_params)
+        optionals = type_params.filter {|param| param.default_type }
+
+        optional_param_names = optionals.map(&:name).sort
+
+        optionals.filter! do |param|
+          default_type = param.default_type or raise
+          optional_param_names.any? { default_type.free_variables.include?(_1) }
+        end
+
+        unless optionals.empty?
+          optionals
+        end
+      end
+    end
+  end
+end

data/lib/rbs/ast/visitor.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    # The Visitor class implements the Visitor pattern for traversing the RBS Abstract Syntax Tree (AST).
+    #
+    # It provides methods to visit each type of node in the AST, allowing for custom processing of each node type.
+    #
+    # This class is designed to be subclassed, with specific visit methods overridden to implement custom behavior for
+    # different node types.
+    #
+    # Example usage:
+    #
+    # ~~~rb
+    # class MyVisitor < RBS::AST::Visitor
+    #   def visit_declaration_class(node)
+    #     puts "Visiting class: #{node.name}"
+    #
+    #     super # call `super` to run the default visiting behavior
+    #   end
+    # end
+    #
+    # visitor = MyVisitor.new
+    # visitor.visit(ast_node)
+    # ~~~
+    class Visitor
+      def visit(node)
+        case node
+        when Declarations::Global
+          visit_declaration_global(node)
+        when Declarations::Class
+          visit_declaration_class(node)
+        when Declarations::Module
+          visit_declaration_module(node)
+        when Declarations::Constant
+          visit_declaration_constant(node)
+        when Declarations::TypeAlias
+          visit_declaration_type_alias(node)
+        when Declarations::Interface
+          visit_declaration_interface(node)
+        when Members::Alias
+          visit_member_alias(node)
+        when Members::ClassInstanceVariable
+          visit_member_class_instance_variable(node)
+        when Members::ClassVariable
+          visit_member_class_variable(node)
+        when Members::InstanceVariable
+          visit_member_instance_variable(node)
+        when Members::Private
+          visit_member_private(node)
+        when Members::Public
+          visit_member_public(node)
+        when Members::MethodDefinition
+          visit_member_method_definition(node)
+        when Members::AttrReader
+          visit_member_attr_reader(node)
+        when Members::AttrWriter
+          visit_member_attr_writer(node)
+        when Members::AttrAccessor
+          visit_member_attr_accessor(node)
+        when Members::Include
+          visit_member_include(node)
+        when Members::Prepend
+          visit_member_prepend(node)
+        when Members::Extend
+          visit_member_extend(node)
+        end
+      end
+
+      def visit_all(nodes)
+        nodes.each do |node|
+          visit(node)
+        end
+      end
+
+      def visit_declaration_global(node)
+      end
+
+      def visit_declaration_class(node)
+        visit_all(node.members)
+      end
+
+      def visit_declaration_module(node)
+        visit_all(node.members)
+      end
+
+      def visit_declaration_constant(node)
+      end
+
+      def visit_declaration_type_alias(node)
+      end
+
+      def visit_declaration_interface(node)
+        visit_all(node.members)
+      end
+
+      def visit_member_alias(node)
+      end
+
+      def visit_member_class_instance_variable(node)
+      end
+
+      def visit_member_class_variable(node)
+      end
+
+      def visit_member_instance_variable(node)
+      end
+
+      def visit_member_private(node)
+      end
+
+      def visit_member_public(node)
+      end
+
+      def visit_member_method_definition(node)
+      end
+
+      def visit_member_attr_reader(node)
+      end
+
+      def visit_member_attr_writer(node)
+      end
+
+      def visit_member_attr_accessor(node)
+      end
+
+      def visit_member_include(node)
+      end
+
+      def visit_member_prepend(node)
+      end
+
+      def visit_member_extend(node)
+      end
+    end
+  end
+end

data/lib/rbs/buffer.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module RBS
+  class Buffer
+    attr_reader :name
+    attr_reader :content
+    attr_reader :parent
+
+    def initialize(name: nil, content:, parent: nil)
+      case
+      when name && content
+        @name = name
+        @content = content
+        @parent = nil
+      when parent && content
+        @name = parent[0].name
+        @content = content
+        @parent = parent
+      end
+    end
+
+    def lines
+      ranges.map { self.content[_1] || raise } #$ String
+    end
+
+    def line_count
+      ranges.size
+    end
+
+    def ranges
+      @ranges ||= begin
+        if content.empty?
+          ranges = [0...0] #: Array[Range[Integer]]
+          lines = [""]
+        else
+          lines = content.lines
+          lines << "" if content.end_with?("\n")
+
+          ranges = [] #: Array[Range[Integer]]
+          offset = 0
+
+          lines.each do |line|
+            size0 = line.size
+            line = line.chomp
+            range = offset...(offset+line.size)
+            ranges << range
+
+            offset += size0
+          end
+        end
+
+        ranges
+      end
+    end
+
+    def pos_to_loc(pos)
+      index = ranges.bsearch_index do |range|
+        pos <= range.end ? true : false
+      end
+
+      if index
+        [index + 1, pos - ranges[index].begin]
+      else
+        [ranges.size + 1, 0]
+      end
+    end
+
+    def loc_to_pos(loc)
+      line, column = loc
+
+      if range = ranges.fetch(line - 1, nil)
+        range.begin + column
+      else
+        last_position
+      end
+    end
+
+    def last_position
+      if ranges.empty?
+        0
+      else
+        ranges[-1].end
+      end
+    end
+
+    def inspect
+      "#<RBS::Buffer:#{__id__} @name=#{name}, @content=#{content.bytesize} bytes, @lines=#{ranges.size} lines,>"
+    end
+
+    def character_offset(byte_offset)
+      top = top_buffer
+      return top.character_offset(byte_offset) unless top.equal?(self)
+
+      keys, vals = (@character_offset_cache ||= [[0], [0]])
+
+      idx = keys.bsearch_index { |k| k > byte_offset }
+      lo = idx ? idx - 1 : keys.size - 1
+
+      base_byte = keys[lo]
+      base_char = vals[lo]
+      delta = byte_offset - base_byte
+      return base_char if delta == 0
+
+      result = base_char + (content.byteslice(base_byte, delta) or raise).length
+
+      if base_byte == keys[-1]
+        keys << byte_offset
+        vals << result
+      end
+
+      result
+    end
+
+    def rbs_location(location, loc2=nil)
+      top = top_buffer
+      if loc2
+        Location.new(top, character_offset(location.start_offset), character_offset(loc2.end_offset))
+      else
+        Location.new(top, character_offset(location.start_offset), character_offset(location.end_offset))
+      end
+    end
+
+    def sub_buffer(lines:, byte_lines_hint: nil)
+      buf = +""
+
+      if byte_lines_hint
+        byte_lines_hint.each_with_index do |range, index|
+          slice = content.byteslice(range.begin, range.end - range.begin) or raise
+          if slice.include?("\n")
+            raise "Line #{index + 1} cannot contain newline character."
+          end
+          buf << slice
+          buf << "\n"
+        end
+      else
+        lines.each_with_index do |range, index|
+          start_pos = range.begin
+          end_pos = range.end
+          slice = content[start_pos...end_pos] or raise
+          if slice.include?("\n")
+            raise "Line #{index + 1} cannot contain newline character."
+          end
+          buf << slice
+          buf << "\n"
+        end
+      end
+
+      buf.chomp!
+
+      Buffer.new(content: buf, parent: [self, lines])
+    end
+
+    def parent_buffer
+      if parent
+        parent[0]
+      end
+    end
+
+    def parent_position(position)
+      parent or raise "#parent_position is unavailable with buffer without parent"
+      return nil unless position <= last_position
+
+      line, column = pos_to_loc(position)
+      parent_range = parent[1][line - 1]
+      parent_range.begin + column
+    end
+
+    def absolute_position(position)
+      if parent_buffer
+        pos = parent_position(position) or return
+        parent_buffer.absolute_position(pos)
+      else
+        position
+      end
+    end
+
+    def top_buffer
+      if parent_buffer
+        parent_buffer.top_buffer
+      else
+        self
+      end
+    end
+
+    def detach
+      Buffer.new(name: name, content: content)
+    end
+  end
+end

data/lib/rbs/builtin_names.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RBS
+  module BuiltinNames
+    class Name
+      attr_reader :name
+
+      def initialize(name:)
+        @name = name
+      end
+
+      def to_s
+        name.to_s
+      end
+
+      def instance_type(*args)
+        Types::ClassInstance.new(name: name, args: args, location: nil)
+      end
+
+      def instance_type?(type)
+        type.is_a?(Types::ClassInstance) && type.name == name
+      end
+
+      def singleton_type
+        @singleton_type ||= Types::ClassSingleton.new(name: name, location: nil)
+      end
+
+      def singleton_type?(type)
+        type.is_a?(Types::ClassSingleton) && type.name == name
+      end
+
+      def self.define(name, namespace: Namespace.root)
+        new(name: TypeName.new(name: name, namespace: namespace))
+      end
+    end
+
+    BasicObject = Name.new(name: TypeName.new(name: :BasicObject, namespace: Namespace.root))
+    Object = Name.new(name: TypeName.new(name: :Object, namespace: Namespace.root))
+    Kernel = Name.new(name: TypeName.new(name: :Kernel, namespace: Namespace.root))
+    String = Name.define(:String)
+    Comparable = Name.define(:Comparable)
+    Enumerable = Name.define(:Enumerable)
+    Class = Name.define(:Class)
+    Module = Name.define(:Module)
+    Array = Name.define(:Array)
+    Hash = Name.define(:Hash)
+    Range = Name.define(:Range)
+    Enumerator = Name.define(:Enumerator)
+    Set = Name.define(:Set)
+    Symbol = Name.define(:Symbol)
+    Integer = Name.define(:Integer)
+    Float = Name.define(:Float)
+    Regexp = Name.define(:Regexp)
+    TrueClass = Name.define(:TrueClass)
+    FalseClass = Name.define(:FalseClass)
+    Numeric = Name.define(:Numeric)
+  end
+end

data/lib/rbs/cli/colored_io.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RBS
+  class CLI
+    class ColoredIO
+      attr_reader :stdout
+
+      def initialize(stdout:)
+        @stdout = stdout
+      end
+
+      def puts_red(string)
+        if can_display_colors?
+          puts "\e[31m#{string}\e[m"
+        else
+          puts string
+        end
+      end
+
+      def puts_green(string)
+        if can_display_colors?
+          puts "\e[32m#{string}\e[m"
+        else
+          puts string
+        end
+      end
+
+      def puts(...)
+        stdout.puts(...)
+      end
+
+      private
+
+      # https://github.com/rubygems/rubygems/blob/ed65279100234a17d65d71fe26de5083984ac5b8/bundler/lib/bundler/vendor/thor/lib/thor/shell/color.rb#L99-L109
+      def can_display_colors?
+        are_colors_supported? && !are_colors_disabled?
+      end
+
+      def are_colors_supported?
+        stdout.tty? && ENV["TERM"] != "dumb"
+      end
+
+      def are_colors_disabled?
+        !ENV['NO_COLOR'].nil? && !ENV.fetch('NO_COLOR', '').empty?
+      end
+    end
+  end
+end