steep 0.13.0 → 0.16.2

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

@@ -1,185 +0,0 @@
-module Ruby
-  module Signature
-    module Test
-      module TypeAssertions
-        module ClassMethods
-          attr_reader :target
-
-          def library(*libs)
-            @libs = libs
-            @env = nil
-            @target = nil
-          end
-
-          def env
-            @env ||= begin
-                       loader = Ruby::Signature::EnvironmentLoader.new
-                       (@libs || []).each do |lib|
-                         loader.add library: lib
-                       end
-
-                       Ruby::Signature::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
-                     Ruby::Signature::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
-                   Ruby::Signature::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
-                 Ruby::Signature::Parser.parse_method_type(method_type, variables: [])
-               when Ruby::Signature::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| Ruby::Signature::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
-                 Ruby::Signature::Parser.parse_method_type(method_type, variables: [])
-               when Ruby::Signature::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| Ruby::Signature::Test::Errors.to_string(x) }
-
-          exception
-        end
-      end
-    end
-  end
-end

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

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

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

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