steep 0.15.0 → 0.17.0

data/vendor/ruby-signature/lib/rbs/test/test_helper.rb

@@ -1,183 +0,0 @@
-module RBS
-  module Test
-    module TypeAssertions
-      module ClassMethods
-        attr_reader :target
-
-        def library(*libs)
-          @libs = libs
-          @env = nil
-          @target = nil
-        end
-
-        def env
-          @env ||= begin
-                     loader = RBS::EnvironmentLoader.new
-                     (@libs || []).each do |lib|
-                       loader.add library: lib
-                     end
-
-                     RBS::Environment.new.tap do |env|
-                       loader.load(env: env)
-                     end
-                   end
-        end
-
-        def builder
-          @builder ||= DefinitionBuilder.new(env: env)
-        end
-
-        def testing(type_or_string)
-          type = case type_or_string
-                 when String
-                   RBS::Parser.parse_type(type_or_string, variables: [])
-                 else
-                   type_or_string
-                 end
-
-          definition = case type
-                       when Types::ClassInstance
-                         builder.build_instance(type.name)
-                       when Types::ClassSingleton
-                         builder.build_singleton(type.name)
-                       else
-                         raise "Test target should be class instance or class singleton: #{type}"
-                       end
-
-          @target = [type, definition]
-        end
-      end
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      def env
-        self.class.env
-      end
-
-      def builder
-        self.class.builder
-      end
-
-      def targets
-        @targets ||= []
-      end
-
-      def target
-        targets.last || self.class.target
-      end
-
-      def testing(type_or_string)
-        type = case type_or_string
-               when String
-                 RBS::Parser.parse_type(type_or_string, variables: [])
-               else
-                 type_or_string
-               end
-
-        definition = case type
-                     when Types::ClassInstance
-                       builder.build_instance(type.name)
-                     when Types::ClassSingleton
-                       builder.build_singleton(type.name)
-                     else
-                       raise "Test target should be class instance or class singleton: #{type}"
-                     end
-
-        targets.push [type, definition]
-
-        if block_given?
-          begin
-            yield
-          ensure
-            targets.pop
-          end
-        else
-          [type, definition]
-        end
-      end
-
-      ruby2_keywords def assert_send_type(method_type, receiver, method, *args, &block)
-        trace = []
-        spy = Spy.wrap(receiver, method)
-        spy.callback = -> (result) { trace << result }
-
-        exception = nil
-
-        begin
-          spy.wrapped_object.__send__(method, *args, &block)
-        rescue => exn
-          exception = exn
-        end
-
-        mt = case method_type
-             when String
-               RBS::Parser.parse_method_type(method_type, variables: [])
-             when RBS::MethodType
-               method_type
-             end
-
-        typecheck = TypeCheck.new(self_class: receiver.class, builder: builder)
-        errors = typecheck.method_call(method, mt, trace.last, errors: [])
-
-        assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.last.inspect}"
-
-        type, definition = target
-        method_types = case
-                       when definition.instance_type?
-                         subst = Substitution.build(definition.declaration.type_params.each.map(&:name),
-                                                    type.args)
-                         definition.methods[method].method_types.map do |method_type|
-                           method_type.sub(subst)
-                         end
-                       when definition.class_type?
-                         definition.methods[method].method_types
-                       end
-
-        all_errors = method_types.map {|t| typecheck.method_call(method, t, trace.last, errors: []) }
-        assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.last.inspect}\n  #{method_types.join(" | ")}"
-
-        if exception
-          raise exception
-        end
-      end
-
-      ruby2_keywords def refute_send_type(method_type, receiver, method, *args, &block)
-        trace = []
-        spy = Spy.wrap(receiver, method)
-        spy.callback = -> (result) { trace << result }
-
-        exception = nil
-        begin
-          spy.wrapped_object.__send__(method, *args, &block)
-        rescue Exception => exn
-          exception = exn
-        end
-
-        mt = case method_type
-             when String
-               RBS::Parser.parse_method_type(method_type, variables: [])
-             when RBS::MethodType
-               method_type
-             end
-
-        mt = mt.update(block: if mt.block
-                                MethodType::Block.new(
-                                  type: mt.block.type.with_return_type(Types::Bases::Any.new(location: nil)),
-                                  required: mt.block.required
-                                )
-                              end,
-                       type: mt.type.with_return_type(Types::Bases::Any.new(location: nil)))
-
-        typecheck = TypeCheck.new(self_class: receiver.class, builder: builder)
-        errors = typecheck.method_call(method, mt, trace.last, errors: [])
-
-        assert_operator exception, :is_a?, ::Exception
-        assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }
-
-        exception
-      end
-    end
-  end
-end

data/vendor/ruby-signature/lib/rbs/test/type_check.rb

@@ -1,254 +0,0 @@
-module RBS
-  module Test
-    class TypeCheck
-      attr_reader :self_class
-      attr_reader :builder
-
-      def initialize(self_class:, builder:)
-        @self_class = self_class
-        @builder = builder
-      end
-
-      def method_call(method_name, method_type, call, errors:)
-        args(method_name, method_type, method_type.type, call.method_call, errors, type_error: Errors::ArgumentTypeError, argument_error: Errors::ArgumentError)
-        self.return(method_name, method_type, method_type.type, call.method_call, errors, return_error: Errors::ReturnTypeError)
-
-        if method_type.block
-          case
-          when !call.block_calls.empty?
-            call.block_calls.each do |block_call|
-              args(method_name, method_type, method_type.block.type, block_call, errors, type_error: Errors::BlockArgumentTypeError, argument_error: Errors::BlockArgumentError)
-              self.return(method_name, method_type, method_type.block.type, block_call, errors, return_error: Errors::BlockReturnTypeError)
-            end
-          when !call.block_given
-            # Block is not given
-            if method_type.block.required
-              errors << Errors::MissingBlockError.new(klass: self_class, method_name: method_name, method_type: method_type)
-            end
-          else
-            # Block is given, but not yielded
-          end
-        else
-          if call.block_given
-            errors << Errors::UnexpectedBlockError.new(klass: self_class, method_name: method_name, method_type: method_type)
-          end
-        end
-
-        errors
-      end
-
-      def args(method_name, method_type, fun, call, errors, type_error:, argument_error:)
-        test = zip_args(call.arguments, fun) do |val, param|
-          unless self.value(val, param.type)
-            errors << type_error.new(klass: self_class,
-                                     method_name: method_name,
-                                     method_type: method_type,
-                                     param: param,
-                                     value: val)
-          end
-        end
-
-        unless test
-          errors << argument_error.new(klass: self_class,
-                                       method_name: method_name,
-                                       method_type: method_type)
-        end
-      end
-
-      def return(method_name, method_type, fun, call, errors, return_error:)
-        unless call.exception
-          unless value(call.return_value, fun.return_type)
-            errors << return_error.new(klass: self_class,
-                                       method_name: method_name,
-                                       method_type: method_type,
-                                       type: fun.return_type,
-                                       value: call.return_value)
-          end
-        end
-      end
-
-      def zip_keyword_args(hash, fun)
-        fun.required_keywords.each do |name, param|
-          if hash.key?(name)
-            yield(hash[name], param)
-          else
-            return false
-          end
-        end
-
-        fun.optional_keywords.each do |name, param|
-          if hash.key?(name)
-            yield(hash[name], param)
-          end
-        end
-
-        hash.each do |name, value|
-          next if fun.required_keywords.key?(name)
-          next if fun.optional_keywords.key?(name)
-
-          if fun.rest_keywords
-            yield value, fun.rest_keywords
-          else
-            return false
-          end
-        end
-
-        true
-      end
-
-      def keyword?(value)
-        value.is_a?(Hash) && value.keys.all? {|key| key.is_a?(Symbol) }
-      end
-
-      def zip_args(args, fun, &block)
-        case
-        when args.empty?
-          if fun.required_positionals.empty? && fun.trailing_positionals.empty? && fun.required_keywords.empty?
-            true
-          else
-            false
-          end
-        when !fun.required_positionals.empty?
-          yield_self do
-            param, fun_ = fun.drop_head
-            yield(args.first, param)
-            zip_args(args.drop(1), fun_, &block)
-          end
-        when fun.has_keyword?
-          yield_self do
-            hash = args.last
-            if keyword?(hash)
-              zip_keyword_args(hash, fun, &block) &&
-                zip_args(args.take(args.size - 1),
-                         fun.update(required_keywords: {}, optional_keywords: {}, rest_keywords: nil),
-                         &block)
-            else
-              fun.required_keywords.empty? &&
-                zip_args(args,
-                         fun.update(required_keywords: {}, optional_keywords: {}, rest_keywords: nil),
-                         &block)
-            end
-          end
-        when !fun.trailing_positionals.empty?
-          yield_self do
-            param, fun_ = fun.drop_tail
-            yield(args.last, param)
-            zip_args(args.take(args.size - 1), fun_, &block)
-          end
-        when !fun.optional_positionals.empty?
-          yield_self do
-            param, fun_ = fun.drop_head
-            yield(args.first, param)
-            zip_args(args.drop(1), fun_, &block)
-          end
-        when fun.rest_positionals
-          yield_self do
-            yield(args.first, fun.rest_positionals)
-            zip_args(args.drop(1), fun, &block)
-          end
-        else
-          false
-        end
-      end
-
-      def value(val, type)
-        case type
-        when Types::Bases::Any
-          true
-        when Types::Bases::Bool
-          true
-        when Types::Bases::Top
-          true
-        when Types::Bases::Bottom
-          false
-        when Types::Bases::Void
-          true
-        when Types::Bases::Self
-          Test.call(val, IS_AP, self_class)
-        when Types::Bases::Nil
-          Test.call(val, IS_AP, ::NilClass)
-        when Types::Bases::Class
-          Test.call(val, IS_AP, Class)
-        when Types::Bases::Instance
-          Test.call(val, IS_AP, self_class)
-        when Types::ClassInstance
-          klass = Object.const_get(type.name.to_s)
-          case
-          when klass == ::Array
-            Test.call(val, IS_AP, klass) && val.all? {|v| value(v, type.args[0]) }
-          when klass == ::Hash
-            Test.call(val, IS_AP, klass) && val.all? {|k, v| value(k, type.args[0]) && value(v, type.args[1]) }
-          when klass == ::Range
-            Test.call(val, IS_AP, klass) && value(val.begin, type.args[0]) && value(val.end, type.args[0])
-          when klass == ::Enumerator
-            if Test.call(val, IS_AP, klass)
-              case val.size
-              when Float::INFINITY
-                values = []
-                ret = self
-                val.lazy.take(10).each do |*args|
-                  values << args
-                  nil
-                end
-              else
-                values = []
-                ret = val.each do |*args|
-                  values << args
-                  nil
-                end
-              end
-
-              values.all? do |v|
-                if v.size == 1
-                  # Only one block argument.
-                  value(v[0], type.args[0]) || value(v, type.args[0])
-                else
-                  value(v, type.args[0])
-                end
-              end &&
-                if ret.equal?(self)
-                  type.args[1].is_a?(Types::Bases::Bottom)
-                else
-                  value(ret, type.args[1])
-                end
-            end
-          else
-            Test.call(val, IS_AP, klass)
-          end
-        when Types::ClassSingleton
-          klass = Object.const_get(type.name.to_s)
-          val == klass
-        when Types::Interface
-          methods = Set.new(Test.call(val, METHODS))
-          decl = builder.env.find_class(type.name)
-          if (definition = builder.build_interface(type.name, decl))
-            definition.methods.each_key.all? do |method_name|
-              methods.member?(method_name)
-            end
-          end
-        when Types::Variable
-          true
-        when Types::Literal
-          val == type.literal
-        when Types::Union
-          type.types.any? {|type| value(val, type) }
-        when Types::Intersection
-          type.types.all? {|type| value(val, type) }
-        when Types::Optional
-          Test.call(val, IS_AP, ::NilClass) || value(val, type.type)
-        when Types::Alias
-          value(val, builder.expand_alias(type.name))
-        when Types::Tuple
-          Test.call(val, IS_AP, ::Array) &&
-            type.types.map.with_index {|ty, index| value(val[index], ty) }.all?
-        when Types::Record
-          Test::call(val, IS_AP, ::Hash)
-        when Types::Proc
-          Test::call(val, IS_AP, ::Proc)
-        else
-          false
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-module RBS
-  class TypeName
-    attr_reader :namespace
-    attr_reader :name
-    attr_reader :kind
-
-    def initialize(namespace:, name:)
-      @namespace = namespace
-      @name = name
-      @kind = case name.to_s[0,1]
-              when /[A-Z]/
-                :class
-              when /[a-z]/
-                :alias
-              when "_"
-                :interface
-              end
-    end
-
-    def ==(other)
-      other.is_a?(self.class) && other.namespace == namespace && other.name == name
-    end
-
-    alias eql? ==
-
-    def hash
-      self.class.hash ^ namespace.hash ^ name.hash
-    end
-
-    def to_s
-      "#{namespace.to_s}#{name}"
-    end
-
-    def to_json(*a)
-      to_s.to_json(*a)
-    end
-
-    def to_namespace
-      namespace.append(self.name)
-    end
-
-    def class?
-      kind == :class
-    end
-
-    def alias?
-      kind == :alias
-    end
-
-    def absolute!
-      self.class.new(namespace: namespace.absolute!, name: name)
-    end
-
-    def absolute?
-      namespace.absolute?
-    end
-
-    def relative!
-      self.class.new(namespace: namespace.relative!, name: name)
-    end
-
-    def interface?
-      kind == :interface
-    end
-
-    def with_prefix(namespace)
-      self.class.new(namespace: namespace + self.namespace, name: name)
-    end
-  end
-end