steep 0.16.0 → 0.16.1

data/vendor/ruby-signature/lib/rbs/errors.rb

@@ -1,187 +0,0 @@
-module RBS
-  class InvalidTypeApplicationError < StandardError
-    attr_reader :type_name
-    attr_reader :args
-    attr_reader :params
-    attr_reader :location
-
-    def initialize(type_name:, args:, params:, location:)
-      @type_name = type_name
-      @args = args
-      @params = params
-      @location = location
-      super "#{Location.to_string location}: #{type_name} expects parameters [#{params.each.map(&:name).join(", ")}], but given args [#{args.join(", ")}]"
-    end
-
-    def self.check!(type_name:, args:, params:, location:)
-      unless args.size == params.size
-        raise new(type_name: type_name, args: args, params: params, location: location)
-      end
-    end
-  end
-
-  class InvalidExtensionParameterError < StandardError
-    attr_reader :type_name
-    attr_reader :extension_name
-    attr_reader :location
-    attr_reader :extension_params
-    attr_reader :class_params
-
-    def initialize(type_name:, extension_name:, extension_params:, class_params:, location:)
-      @type_name = type_name
-      @extension_name = extension_name
-      @extension_params = extension_params
-      @class_params = class_params
-      @location = location
-
-      super "#{Location.to_string location}: Expected #{class_params.size} parameters to #{type_name} (#{extension_name}) but has #{extension_params.size} parameters"
-    end
-
-    def self.check!(type_name:, extension_name:, extension_params:, class_params:, location:)
-      unless extension_params.size == class_params.size
-        raise new(type_name: type_name,
-                  extension_name: extension_name,
-                  extension_params: extension_params,
-                  class_params: class_params,
-                  location: location)
-      end
-    end
-  end
-
-  class RecursiveAncestorError < StandardError
-    attr_reader :ancestors
-    attr_reader :location
-
-    def initialize(ancestors:, location:)
-      last = case last = ancestors.last
-             when Definition::Ancestor::Singleton
-               "singleton(#{last.name})"
-             when Definition::Ancestor::Instance
-               if last.args.empty?
-                 last.name.to_s
-               else
-                 "#{last.name}[#{last.args.join(", ")}]"
-               end
-             end
-
-      super "#{Location.to_string location}: Detected recursive ancestors: #{last}"
-    end
-
-    def self.check!(self_ancestor, ancestors:, location:)
-      case self_ancestor
-      when Definition::Ancestor::Instance
-        if ancestors.any? {|a| a.is_a?(Definition::Ancestor::Instance) && a.name == self_ancestor.name }
-          raise new(ancestors: ancestors + [self_ancestor], location: location)
-        end
-      when Definition::Ancestor::Singleton
-        if ancestors.include?(self_ancestor)
-          raise new(ancestors: ancestors + [self_ancestor], location: location)
-        end
-      end
-    end
-  end
-
-  class NoTypeFoundError < StandardError
-    attr_reader :type_name
-    attr_reader :location
-
-    def initialize(type_name:, location:)
-      @type_name = type_name
-      @location = location
-
-      super "#{Location.to_string location}: Could not find #{type_name}"
-    end
-
-    def self.check!(type_name, env:, location:)
-      env.find_type_decl(type_name) or
-        raise new(type_name: type_name, location: location)
-
-      type_name
-    end
-  end
-
-  class DuplicatedMethodDefinitionError < StandardError
-    attr_reader :decl
-    attr_reader :location
-
-    def initialize(decl:, name:, location:)
-      decl_str = case decl
-                 when AST::Declarations::Interface, AST::Declarations::Class, AST::Declarations::Module
-                   decl.name.to_s
-                 when AST::Declarations::Extension
-                   "#{decl.name} (#{decl.extension_name})"
-                 end
-
-      super "#{Location.to_string location}: #{decl_str} has duplicated method definition: #{name}"
-    end
-
-    def self.check!(decl:, methods:, name:, location:)
-      if methods.key?(name)
-        raise new(decl: decl, name: name, location: location)
-      end
-    end
-  end
-
-  class UnknownMethodAliasError < StandardError
-    attr_reader :original_name
-    attr_reader :aliased_name
-    attr_reader :location
-
-    def initialize(original_name:, aliased_name:, location:)
-      @original_name = original_name
-      @aliased_name = aliased_name
-      @location = location
-
-      super "#{Location.to_string location}: Unknown method alias name: #{original_name} => #{aliased_name}"
-    end
-
-    def self.check!(methods:, original_name:, aliased_name:, location:)
-      unless methods.key?(original_name)
-        raise new(original_name: original_name, aliased_name: aliased_name, location: location)
-      end
-    end
-  end
-
-  class DuplicatedDeclarationError < StandardError
-    attr_reader :name
-    attr_reader :decls
-
-    def initialize(name, *decls)
-      @name = name
-      @decls = decls
-
-      super "#{Location.to_string decls.last.location}: Duplicated declaration: #{name}"
-    end
-  end
-
-  class InvalidVarianceAnnotationError < StandardError
-    MethodTypeError = Struct.new(:method_name, :method_type, :param, keyword_init: true)
-    InheritanceError = Struct.new(:super_class, :param, keyword_init: true)
-    MixinError = Struct.new(:include_member, :param, keyword_init: true)
-
-    attr_reader :decl
-    attr_reader :errors
-
-    def initialize(decl:, errors:)
-      @decl = decl
-      @errors = errors
-
-      message = [
-        "#{Location.to_string decl.location}: Invalid variance annotation: #{decl.name}"
-      ]
-
-      errors.each do |error|
-        case error
-        when MethodTypeError
-          message << "  MethodTypeError (#{error.param.name}): on `#{error.method_name}` #{error.method_type.to_s} (#{error.method_type.location&.start_line})"
-        when InheritanceError
-          message << "  InheritanceError: #{error.super_class}"
-        when MixinError
-          message << "  MixinError: #{error.include_member.name} (#{error.include_member.location&.start_line})"
-        end
-      end
-
-      super message.join("\n")
-    end
-  end
-end

data/vendor/ruby-signature/lib/rbs/location.rb

@@ -1,102 +0,0 @@
-module RBS
-  class Location
-    attr_reader :buffer
-    attr_reader :start_pos
-    attr_reader :end_pos
-
-    def initialize(buffer:, start_pos:, end_pos:)
-      @buffer = buffer
-      @start_pos = start_pos
-      @end_pos = end_pos
-    end
-
-    def inspect
-      "#<#{self.class}:#{self.__id__} @buffer=#{buffer.name}, @pos=#{start_pos}...#{end_pos}, source='#{source.lines.first}', start_line=#{start_line}, start_column=#{start_column}>"
-    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.pos_to_loc(start_pos)
-    end
-
-    def end_loc
-      @end_loc ||= buffer.pos_to_loc(end_pos)
-    end
-
-    def source
-      @source ||= buffer.content[start_pos...end_pos]
-    end
-
-    def to_s
-      "#{name || "-"}:#{start_line}:#{start_column}...#{end_line}:#{end_column}"
-    end
-
-    def self.to_string(location, default: "*:*:*...*:*")
-      location&.to_s || default
-    end
-
-    def ==(other)
-      other.is_a?(Location) &&
-        other.buffer == buffer &&
-        other.start_pos == start_pos &&
-        other.end_pos == end_pos
-    end
-
-    def +(other)
-      if other
-        raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
-
-        self.class.new(buffer: buffer,
-                       start_pos: start_pos,
-                       end_pos: other.end_pos)
-      else
-        self
-      end
-    end
-
-    def self.concat(*locations)
-      locations.inject {|l1, l2| l1 + l2 }
-    end
-
-    def pred?(loc)
-      loc.is_a?(Location) &&
-        loc.name == name &&
-        loc.start_pos == end_pos
-    end
-
-    def to_json(*args)
-      {
-        start: {
-          line: start_line,
-          column: start_column
-        },
-        end: {
-          line: end_line,
-          column: end_column
-        },
-        buffer: {
-          name: name&.to_s
-        }
-      }.to_json(*args)
-    end
-  end
-end

data/vendor/ruby-signature/lib/rbs/method_type.rb

@@ -1,123 +0,0 @@
-module RBS
-  class MethodType
-    class Block
-      attr_reader :type
-      attr_reader :required
-
-      def initialize(type:, required:)
-        @type = type
-        @required = required
-      end
-
-      def ==(other)
-        other.is_a?(Block) &&
-          other.type == type &&
-          other.required == required
-      end
-
-      def to_json(*a)
-        {
-          type: type,
-          required: required
-        }.to_json(*a)
-      end
-
-      def sub(s)
-        self.class.new(
-          type: type.sub(s),
-          required: required
-        )
-      end
-    end
-
-    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(*a)
-      {
-        type_params: type_params,
-        type: type,
-        block: block,
-        location: location
-      }.to_json(*a)
-    end
-
-    def sub(s)
-      s.without(*type_params).yield_self do |sub|
-        map_type do |ty|
-          ty.sub(sub)
-        end
-      end
-    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_params)
-    end
-
-    def map_type(&block)
-      self.class.new(
-        type_params: type_params,
-        type: type.map_type(&block),
-        block: self.block&.yield_self do |b|
-          Block.new(type: b.type.map_type(&block), required: b.required)
-        end,
-        location: location
-      )
-    end
-
-    def each_type(&block)
-      if block_given?
-        type.each_type(&block)
-        self.block&.yield_self do |b|
-          b.type.each_type(&block)
-        end
-      else
-        enum_for :each_type
-      end
-    end
-
-    def to_s
-      s = case
-          when block && block.required
-            "(#{type.param_to_s}) { (#{block.type.param_to_s}) -> #{block.type.return_to_s} } -> #{type.return_to_s}"
-          when block
-            "(#{type.param_to_s}) ?{ (#{block.type.param_to_s}) -> #{block.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
-  end
-end

data/vendor/ruby-signature/lib/rbs/namespace.rb

@@ -1,91 +0,0 @@
-module RBS
-  class Namespace
-    attr_reader :path
-
-    def initialize(path:, absolute:)
-      @path = path
-      @absolute = absolute
-    end
-
-    def self.empty
-      new(path: [], absolute: false)
-    end
-
-    def self.root
-      new(path: [], absolute: true)
-    end
-
-    def +(other)
-      if other.absolute?
-        other
-      else
-        self.class.new(path: path + other.path, absolute: absolute?)
-      end
-    end
-
-    def append(component)
-      self.class.new(path: path + [component], absolute: absolute?)
-    end
-
-    def parent
-      raise "Parent with empty namespace" if empty?
-      self.class.new(path: path.take(path.size - 1), absolute: absolute?)
-    end
-
-    def absolute?
-      @absolute
-    end
-
-    def relative?
-      !absolute?
-    end
-
-    def absolute!
-      self.class.new(path: path, absolute: true)
-    end
-
-    def relative!
-      self.class.new(path: path, absolute: false)
-    end
-
-    def empty?
-      path.empty?
-    end
-
-    def ==(other)
-      other.is_a?(Namespace) && other.path == path && other.absolute? == absolute?
-    end
-
-    alias eql? ==
-
-    def hash
-      self.class.hash ^ path.hash ^ absolute?.hash
-    end
-
-    def split
-      [parent, path.last]
-    end
-
-    def to_s
-      if empty?
-        absolute? ? "::" : ""
-      else
-        s = path.join("::")
-        absolute? ? "::#{s}::" : "#{s}::"
-      end
-    end
-
-    def to_type_name
-      parent, name = split
-      TypeName.new(name: name, namespace: parent)
-    end
-
-    def self.parse(string)
-      if string.start_with?("::")
-        new(path: string.split("::").drop(1).map(&:to_sym), absolute: true)
-      else
-        new(path: string.split("::").map(&:to_sym), absolute: false)
-      end
-    end
-  end
-end