steep 0.11.1 → 0.12.0

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

@@ -0,0 +1,189 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,125 @@
+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

@@ -0,0 +1,93 @@
+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