rbs 3.3.2 → 3.4.0

data/lib/rbs/unit_test/type_assertions.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+module RBS
+  module UnitTest
+    module TypeAssertions
+      module ClassMethods
+        attr_reader :target
+
+        def library(*libs)
+          if @libs
+            raise "Multiple #library calls are not allowed"
+          end
+
+          @libs = libs
+          @env = nil
+          @target = nil
+        end
+
+        @@env_cache = {}
+
+        def env
+          @env = @@env_cache[@libs] ||=
+            begin
+              loader = RBS::EnvironmentLoader.new
+              (@libs || []).each do |lib|
+                loader.add(library: lib, version: nil)
+              end
+
+              RBS::Environment.from_loader(loader).resolve_type_names
+            end
+        end
+
+        def builder
+          @builder ||= RBS::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: []) || raise
+                 else
+                   type_or_string
+                 end
+
+          definition = case type
+                       when RBS::Types::ClassInstance
+                         builder.build_instance(type.name)
+                       when RBS::Types::ClassSingleton
+                         builder.build_singleton(type.name)
+                       else
+                         raise "Test target should be class instance or class singleton: #{type}"
+                       end
+
+          @target = [type, definition] #: [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 RBS::Types::ClassInstance
+                       builder.build_instance(type.name)
+                     when RBS::Types::ClassSingleton
+                       builder.build_singleton(type.name)
+                     else
+                       raise "Test target should be class instance or class singleton: #{type}"
+                     end
+
+        targets.push(
+          [
+            type,  #: target_type
+            definition
+          ]
+        )
+
+        if block_given?
+          begin
+            yield
+          ensure
+            targets.pop
+          end
+        else
+          [type, definition]
+        end
+      end
+
+      def instance_class
+        type, _ = target
+
+        case type
+        when RBS::Types::ClassSingleton, RBS::Types::ClassInstance
+          Object.const_get(type.name.to_s)
+        end
+      end
+
+      def class_class
+        type, _ = target
+
+        case type
+        when RBS::Types::ClassSingleton, RBS::Types::ClassInstance
+          Object.const_get(type.name.to_s).singleton_class
+        end
+      end
+
+      def send_setup(method_type, receiver, method, args, proc)
+        mt =
+          case method_type
+          when String
+            RBS::Parser.parse_method_type(method_type, variables: []) || raise
+          when RBS::MethodType
+            method_type
+          end
+
+        validate_simple_method_type(mt)
+
+        trace = [] #: Array[Test::CallTrace]
+        spy = Spy.wrap(receiver, method)
+        spy.callback = -> (result) { trace << result }
+
+        result = nil #: untyped
+        exception = nil #: Exception?
+        non_jump_exit = true
+
+        begin
+          result = catch do |tag|
+            @break_tag = tag
+            spy.wrapped_object.__send__(method, *args, &proc)
+          ensure
+            @break_tag = nil
+          end
+
+          non_jump_exit = false
+        rescue Exception => exn
+          exception = exn
+        ensure
+          if non_jump_exit && !exception
+            raise "`break` nor `return` from blocks given to `assert_send_type` are prohibited. Use `#break_from_block` instead."
+          end
+        end
+
+        last_trace = trace.last or raise
+
+        yield(mt, last_trace, result, exception)
+      end
+
+      ruby2_keywords def assert_send_type(method_type, receiver, method, *args, &block)
+        send_setup(method_type, receiver, method, args, block) do |method_type, trace, result, exception|
+          typecheck = RBS::Test::TypeCheck.new(
+            self_class: receiver.class,
+            builder: builder,
+            sample_size: 100,
+            unchecked_classes: [],
+            instance_class: instance_class,
+            class_class: class_class
+          )
+          errors = typecheck.method_call(method, method_type, trace, errors: [])
+
+          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
+
+          method_types = method_types(method)
+          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
+          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_types.join(" | ")}"
+
+          raise exception if exception
+
+          result
+        end
+      end
+
+      ruby2_keywords def refute_send_type(method_type, receiver, method, *args, &block)
+        send_setup(method_type, receiver, method, args, block) do |method_type, trace, result, exception|
+          method_type = method_type.update(
+            block:
+              if method_type.block
+                RBS::Types::Block.new(
+                  type: method_type.block.type.with_return_type(RBS::Types::Bases::Any.new(location: nil)),
+                  required: method_type.block.required,
+                  self_type: nil
+                )
+              end,
+            type: method_type.type.with_return_type(RBS::Types::Bases::Any.new(location: nil))
+          )
+
+          typecheck = RBS::Test::TypeCheck.new(
+            self_class: receiver.class,
+            instance_class: instance_class,
+            class_class: class_class,
+            builder: builder,
+            sample_size: 100,
+            unchecked_classes: []
+          )
+          errors = typecheck.method_call(method, method_type, trace, errors: [])
+
+          assert_operator exception, :is_a?, ::Exception
+          assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }
+
+          method_types = method_types(method)
+          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
+          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_types.join(" | ")}"
+
+          result
+        end
+      end
+
+      def method_types(method)
+        type, definition = target
+
+        case type
+        when Types::ClassInstance
+          subst = RBS::Substitution.build(definition.type_params, type.args)
+          definition.methods[method].method_types.map do |method_type|
+            method_type.sub(subst)
+          end
+        when Types::ClassSingleton
+          definition.methods[method].method_types
+        else
+          raise
+        end
+      end
+
+      def allows_error(*errors)
+        yield
+      rescue *errors => exn
+        notify "Error allowed: #{exn.inspect}"
+      end
+
+      def assert_const_type(type, constant_name)
+        constant = Object.const_get(constant_name)
+
+        typecheck = RBS::Test::TypeCheck.new(
+          self_class: constant.class,
+          instance_class: instance_class,
+          class_class: class_class,
+          builder: builder,
+          sample_size: 100,
+          unchecked_classes: []
+        )
+
+        value_type =
+          case type
+          when String
+            RBS::Parser.parse_type(type, variables: []) || raise
+          else
+            type
+          end
+
+        assert typecheck.value(constant, value_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with given type `#{value_type}`"
+
+        type_name = TypeName(constant_name).absolute!
+        definition = env.constant_entry(type_name)
+        assert definition, "Cannot find RBS type definition of `#{constant_name}`"
+
+        case definition
+        when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+          definition_type = RBS::Types::ClassSingleton.new(name: type_name, location: nil)
+        when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+          type_name = env.normalize_type_name!(type_name)
+          definition_type = RBS::Types::ClassSingleton.new(name: type_name, location: nil)
+        when RBS::Environment::ConstantEntry
+          definition_type = definition.decl.type
+        end
+
+        assert definition_type, "Cannot find RBS entry for `#{constant_name}`"
+        definition_type or raise
+        assert typecheck.value(constant, definition_type), "`#{constant_name}` (#{constant.inspect}) must be compatible with RBS type definition `#{definition_type}`"
+      end
+
+      def assert_type(type, value)
+        typecheck = RBS::Test::TypeCheck.new(
+          self_class: value.class,
+          instance_class: _ = "No `instance` class allowed",
+          class_class: _ = "No `class` class allowed",
+          builder: builder,
+          sample_size: 100,
+          unchecked_classes: []
+        )
+
+        type =
+          case type
+          when String
+            RBS::Parser.parse_type(type, variables: []) or raise
+          else
+            type
+          end
+
+        assert typecheck.value(value, type), "`#{value.inspect}` must be compatible with given type `#{type}`"
+      end
+
+      def allow_non_simple_method_type()
+        begin
+          @allows_non_simple_method_type = true
+          yield
+        rescue
+          @allows_non_simple_method_type = false
+        end
+      end
+
+      def validate_simple_method_type(type)
+        return if @allows_non_simple_method_type
+
+        refute_predicate type, :has_self_type?, "`self` types is prohibited in method type: `#{type}`"
+        refute_predicate type, :has_classish_type?, "`instance` and `class` types is prohibited in method type: `#{type}`"
+        refute_predicate type, :with_nonreturn_void?, "`void` is only allowed at return type or generics parameters: `#{type}`"
+      end
+
+      def break_from_block(value = nil)
+        raise "Cannot break without `@break_tag`" unless @break_tag
+        throw @break_tag, value
+      end
+
+      def pass(message = nil)
+        assert true, message
+      end
+    end
+  end
+end

data/lib/rbs/unit_test/with_aliases.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RBS
+  module UnitTest
+    module WithAliases
+      include Convertibles
+
+      class WithEnum
+        include Enumerable
+
+        def initialize(enum) = @enum = enum
+
+        def each(&block) = @enum.each(&block)
+
+        def and_nil(&block)
+          self.and(nil, &_ = block)
+        end
+
+        def but(*cases, &block)
+          return WithEnum.new to_enum(__method__ || raise, *cases) unless block
+
+          each do |arg|
+            yield arg unless cases.any? { (_ = _1) === arg }
+          end
+        end
+
+        def and(*args, &block)
+          return WithEnum.new to_enum(__method__ || raise, *args) unless block
+
+          each(&block)
+          args.each do |arg|
+            if WithEnum === arg # use `===` as `arg` might not have `.is_a?` on it
+              arg.each(&block)
+            else
+              block.call(_ = arg)
+            end
+          end
+        end
+      end
+
+      def with(*args, &block)
+        return WithEnum.new to_enum(__method__ || raise, *args) unless block
+        args.each(&block)
+      end
+
+      def with_int(value = 3, &block)
+        return WithEnum.new to_enum(__method__ || raise, value) unless block
+        yield value
+        yield ToInt.new(value)
+      end
+
+      def with_float(value = 0.1)
+        return WithEnum.new to_enum(__method__ || raise, value) unless block_given?
+        yield value
+        yield ToF.new(value)
+      end
+
+      def with_string(value = '')
+        return WithEnum.new to_enum(__method__ || raise, value) unless block_given?
+        yield value
+        yield ToStr.new(value)
+      end
+
+      def with_array(*elements)
+        return WithEnum.new to_enum(__method__ || raise, *elements) unless block_given?
+
+        yield _ = elements
+        yield ToArray.new(*elements)
+      end
+
+      def with_hash(hash = {})
+        return WithEnum.new to_enum(__method__ || raise, hash) unless block_given?
+
+        yield _ = hash
+        yield ToHash.new(hash)
+      end
+
+      def with_io(io = $stdout)
+        return WithEnum.new to_enum(__method__ || raise, io) unless block_given?
+        yield io
+        yield ToIO.new(io)
+      end
+
+      def with_path(path = "/tmp/foo.txt", &block)
+        return WithEnum.new to_enum(__method__ || raise, path) unless block
+
+        with_string(path, &block)
+        block.call ToPath.new(path)
+      end
+
+      def with_encoding(encoding = Encoding::UTF_8, &block)
+        return WithEnum.new to_enum(__method__ || raise, encoding) unless block
+
+        block.call encoding
+        with_string(encoding.to_s, &block)
+      end
+
+      def with_interned(value = :&, &block)
+        return WithEnum.new to_enum(__method__ || raise, value) unless block
+
+        with_string(value.to_s, &block)
+        block.call value.to_sym
+      end
+
+      def with_bool(&block)
+        return WithEnum.new to_enum(__method__ || raise) unless block
+        yield true
+        yield false
+      end
+
+      def with_boolish(&block)
+        return WithEnum.new to_enum(__method__ || raise) unless block
+        with_bool(&block)
+        [nil, 1, Object.new, BlankSlate.new, "hello, world!"].each(&block)
+      end
+
+      alias with_untyped with_boolish
+
+      def with_range(start, stop, exclude_end = false)
+        # If you need fixed starting and stopping points, you can just do `with_range with(1), with(2)`.
+        raise ArgumentError, '`start` must be from a `with` method' unless start.is_a? WithEnum
+        raise ArgumentError, '`stop` must be from a `with` method' unless stop.is_a? WithEnum
+
+        start.each do |lower|
+          stop.each do |upper|
+            yield CustomRange.new(lower, upper, exclude_end)
+
+            # `Range` requires `begin <=> end` to return non-nil, but doesn't actually
+            # end up using the return value of it. This is to add that in when needed.
+            def lower.<=>(rhs) = :not_nil unless defined? lower.<=>
+
+            # If `lower <=> rhs` is defined but nil, then that means we're going to be constructing
+            # an illegal range (eg `3..ToInt.new(4)`). So, we need to skip yielding an invalid range
+            # in that case.
+            next if defined?(lower.<=>) && nil == (lower <=> upper)
+
+            yield Range.new(lower, upper, exclude_end)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/unit_test.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require "rbs/test"
+require "rbs/unit_test/spy"
+require "rbs/unit_test/type_assertions"
+require "rbs/unit_test/convertibles"
+require "rbs/unit_test/with_aliases"

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.3.2"
+  VERSION = "3.4.0"
 end

data/sig/cli/validate.rbs

@@ -0,0 +1,43 @@
+module RBS
+  class CLI
+    class Validate
+      class Errors
+        @limit: Integer?
+        @exit_error: boolish
+        @has_syntax_error: bool
+        @errors: Array[BaseError]
+
+        def initialize: (limit: Integer?, exit_error: boolish) -> void
+
+        def add: (BaseError) -> void
+
+        def finish: () -> void
+
+        private
+
+        def build_message: (BaseError) -> String
+      end
+
+      @env: Environment
+      @builder: RBS::DefinitionBuilder
+      @validator: RBS::Validator
+      @errors: Errors
+
+      def initialize: (args: Array[String], options: LibraryOptions) -> void
+
+      def run: () -> void
+
+      private
+
+      def validate_class_module_definition: () -> void
+      def validate_class_module_alias_definition: () -> void
+      def validate_interface: () -> void
+      def validate_constant: () -> void
+      def validate_global: () -> void
+      def validate_type_alias: () -> void
+      def no_self_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
+      def no_classish_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
+      def void_type_context_validator: (::RBS::Types::t | ::RBS::MethodType type, ?bool allowed_here) -> void
+    end
+  end
+end

data/sig/diff.rbs

@@ -4,12 +4,14 @@ module RBS
     @library_options: RBS::CLI::LibraryOptions
     @after_path: Array[String]
     @before_path: Array[String]
+    @detail: boolish
 
     def initialize: (
       type_name: TypeName,
       library_options: RBS::CLI::LibraryOptions,
       ?after_path: Array[String],
-      ?before_path: Array[String]
+      ?before_path: Array[String],
+      ?detail: boolish
     ) -> void
 
     def each_diff: () { (String before, String after) -> void } -> void

data/sig/errors.rbs

@@ -357,4 +357,12 @@ module RBS
 
     def location: () -> AST::Declarations::AliasDecl::loc?
   end
+
+  class WillSyntaxError < BaseError
+    include RBS::DetailedMessageable
+
+    def initialize: (String message, location: Location[untyped, untyped]?) -> void
+
+    def location: () -> Location[untyped, untyped]?
+  end
 end

data/sig/rbs.rbs

@@ -5,7 +5,7 @@ module RBS
 
   def self.logger_level=: (Integer?) -> Integer?
 
-  def self.logger_output: () -> IO
+  %a{pure} def self.logger_output: () -> IO?
 
   def self.logger_output=: (IO) -> IO
 

data/sig/test/errors.rbs

@@ -0,0 +1,52 @@
+module RBS
+  module Test
+    module Errors
+      type t = ArgumentTypeError | BlockArgumentError | ArgumentError | BlockArgumentError | ReturnTypeError | BlockReturnTypeError
+             | UnexpectedBlockError | MissingBlockError | UnresolvedOverloadingError
+
+      # Type of a argument value given to a method call is not compatible with the type from method type
+      class ArgumentTypeError
+      end
+
+      # Type of a argument value given to a block yield is not compatible with the type from method type
+      class BlockArgumentTypeError
+      end
+
+      # Incompatible number of args/keyword args is given to a method call
+      class ArgumentError
+      end
+
+      # Incompatible number of args is given to a block yield
+      class BlockArgumentError
+      end
+
+      # Type of return value from a method call is incompatible
+      class ReturnTypeError
+      end
+
+      # Type of return value from a block yield is incompatible
+      class BlockReturnTypeError
+      end
+
+      # Unexpected block is given
+      class UnexpectedBlockError
+      end
+
+      # Required block is missing
+      class MissingBlockError
+      end
+
+      # Any other error
+      class UnresolvedOverloadingError
+      end
+
+      def self.format_param: (Types::Function::Param) -> String
+
+      RESPOND_TO: UnboundMethod
+
+      def self.inspect_: (untyped) -> String
+
+      def self.to_string: (t) -> String
+    end
+  end
+end

data/sig/test/guranteed.rbs

@@ -0,0 +1,9 @@
+module RBS
+  module Test
+    module Guaranteed
+      module Inspect
+        def self?.guaranteed_inspect: (untyped) -> String
+      end
+    end
+  end
+end

data/sig/test/type_check.rbs

@@ -0,0 +1,19 @@
+module RBS
+  module Test
+    class TypeCheck
+      def initialize: (self_class: Module, builder: DefinitionBuilder, sample_size: Integer, unchecked_classes: Array[Module], instance_class: Module, class_class: Module) -> void
+
+      # Confirm if given `CallTrace` is compatible with `MethodType`
+      #
+      # Returns an array with detected errors.
+      #
+      def method_call: (Symbol, MethodType, CallTrace, errors: Array[Errors::t]) -> Array[Errors::t]
+
+      # Test if given `value` is compatible to type
+      #
+      # Returns `true` if the value has the type.
+      # 
+      def value: (untyped value, Types::t) -> bool
+    end
+  end
+end