steep 0.14.0 → 0.15.0

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

@@ -1,189 +0,0 @@
-module Ruby
-  module Signature
-    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
-end

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

@@ -1,104 +0,0 @@
-module Ruby
-  module Signature
-    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
-end

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

@@ -1,125 +0,0 @@
-module Ruby
-  module Signature
-    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
-end

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

@@ -1,93 +0,0 @@
-module Ruby
-  module Signature
-    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
-end