rbs 2.8.4 → 3.8.1

data/sig/unit_test/convertibles.rbs

@@ -0,0 +1,154 @@
+module RBS
+  module UnitTest
+    module Convertibles
+      # An object that doesn't have methods excepts `__send__` and `__id__`
+      #
+      # Other methods are `undef`ed.
+      #
+      class BlankSlate < BasicObject
+        # Add Object methods to `self`
+        #
+        def __with_object_methods: (*Symbol methods) -> self
+      end
+
+      # An object with `#to_io` method
+      class ToIO < BlankSlate
+        @io: untyped
+
+        def initialize: (?untyped io) -> void
+
+        def to_io: () -> untyped
+      end
+
+      # An object with `#to_i` method
+      class ToI < BlankSlate
+        @value: untyped
+
+        def initialize: (?untyped value) -> void
+
+        def to_i: () -> untyped
+      end
+
+      # An object with `#to_int` method
+      class ToInt < BlankSlate
+        @value: untyped
+
+        def initialize: (?untyped value) -> void
+
+        def to_int: () -> untyped
+      end
+
+      # An object with `#to_f` method
+      class ToF < BlankSlate
+        @value: untyped
+
+        def initialize: (?untyped value) -> void
+
+        def to_f: () -> untyped
+      end
+
+      # An object with `#to_r` method
+      class ToR < BlankSlate
+        @value: untyped
+
+        def initialize: (?untyped value) -> void
+
+        def to_r: () -> untyped
+      end
+
+      # An object with `#to_c` method
+      class ToC < BlankSlate
+        @value: untyped
+
+        def initialize: (?untyped value) -> void
+
+        def to_c: () -> untyped
+      end
+
+      # An object with `#to_str` method
+      class ToStr < BlankSlate
+        @value: untyped
+
+        def initialize: (?untyped value) -> void
+
+        def to_str: () -> untyped
+      end
+
+      # An object with `#to_s` method
+      class ToS < BlankSlate
+        @value: untyped
+
+        def initialize: (?untyped value) -> void
+
+        def to_s: () -> untyped
+      end
+
+      # An object with `#to_sym` method
+      class ToSym < BlankSlate
+        @value: untyped
+
+        def initialize: (?untyped value) -> void
+
+        def to_sym: () -> untyped
+      end
+
+      # An object with `#to_a` method
+      class ToA < BlankSlate
+        @args: untyped
+
+        def initialize: (*untyped args) -> void
+
+        def to_a: () -> Array[untyped]
+      end
+
+      # An object with `#to_ary` method
+      class ToArray < BlankSlate
+        @args: untyped
+
+        def initialize: (*untyped args) -> void
+
+        def to_ary: () -> Array[untyped]
+      end
+
+      # An object with `#to_hash` method
+      class ToHash < BlankSlate
+        @hash: untyped
+
+        def initialize: (?::Hash[untyped, untyped] hash) -> void
+
+        def to_hash: () -> Hash[untyped, untyped]
+      end
+
+      # An object with `#to_path` method
+      class ToPath < BlankSlate
+        @value: untyped
+
+        def initialize: (?untyped value) -> void
+
+        def to_path: () -> untyped
+      end
+
+      # An object with `#begin`, `#end`, and `#exclude_end`
+      class CustomRange < BlankSlate
+        @exclude_end: untyped
+
+        attr_reader begin: untyped
+
+        attr_reader end: untyped
+
+        def initialize: (untyped begin_, untyped end_, ?untyped exclude_end) -> void
+
+        def exclude_end?: () -> untyped
+      end
+
+      # An object with `#each` method
+      class Each < BlankSlate
+        @args: Array[untyped]
+
+        def initialize: (*untyped args) -> void
+
+        def each: () { (untyped) -> void } -> untyped
+      end
+    end
+  end
+end

data/sig/unit_test/spy.rbs

@@ -0,0 +1,28 @@
+module RBS
+  module UnitTest
+    module Spy
+      def self.wrap: [T] (untyped object, Symbol method_name) -> WrapSpy[T]
+                   | [T, S] (untyped object, Symbol method_name) { (WrapSpy[T], T) -> S } -> S
+
+      class WrapSpy[T]
+        attr_accessor callback: ^(Test::CallTrace) -> void
+
+        attr_reader object: T
+
+        attr_reader method_name: Symbol
+
+        def initialize: (object: T, method_name: Symbol) -> void
+
+        def wrapped_object: () -> untyped
+      end
+    end
+  end
+end
+
+class Proc
+  def ruby2_keywords: () -> self
+end
+
+class Module
+  def ruby2_keywords: (*Symbol) -> void
+end

data/sig/unit_test/type_assertions.rbs

@@ -0,0 +1,194 @@
+module RBS
+  module UnitTest
+    # TypeAssertions provides assertions to test RBS type definitions in unit test
+    #
+    # ```ruby
+    # class FooInstanceTest < Test::Unit::TestCase
+    #   include RBS::UnitTest::TypeAssertions
+    #
+    #   testing "::Foo"
+    #
+    #   def test_foo
+    #     assert_send_type(
+    #       "(String) -> Integer",
+    #       Foo.new, :foo, "hello"
+    #     )
+    #   end
+    # end
+    # ```
+    #
+    # The module provides four assertions:
+    #
+    # * `assert_send_type` to confirm if a method call has the expected method type
+    # * `refute_send_type` to confirm if a method call doesn't have the method type
+    # * `assert_const_type` to confirm if a constant has an expected type
+    # * `assert_type` to confirm a Ruby value has a RBS type
+    #
+    # See `.testing` and `.library` methods to set up RBS type testing.
+    #
+    module TypeAssertions : _BaseAssertions
+      type target_type = Types::ClassInstance | Types::ClassSingleton
+
+      interface _BaseAssertions
+        def assert: (untyped, ?String?) -> void
+
+        def refute: (untyped, ?String?) -> void
+
+        def assert_empty: (untyped, ?String?) -> void
+
+        def assert_operator: (untyped, Symbol, *untyped) -> void
+
+        def notify: (untyped) -> void
+
+        def assert_predicate: (untyped, Symbol, ?String?) -> void
+
+        def refute_predicate: (untyped, Symbol, ?String?) -> void
+      end
+
+      module ClassMethods
+        attr_reader target: [target_type, Definition]?
+
+        @libs: Array[String]
+
+        @env: Environment?
+
+        @@env_cache: Hash[Array[String], Environment]
+
+        # `testing` is to tell the framework which class is being tested
+        #
+        # ```ruby
+        # testing "::String"
+        # testing "::Array[Integer]"
+        #
+        # testing "singleton(::Integer)"
+        # ```
+        #
+        def testing: (String | target_type) -> void
+
+        # `library` is to load RBS type definition of dependencies
+        #
+        # The test or implementation already `require` dependencies, but the RBS type definition of the dependencies are also required for testing.
+        #
+        # ```ruby
+        # library "pathname", "securerandom"
+        # ```
+        #
+        def library: (*String) -> void
+
+        def env: () -> Environment
+
+        @builder: DefinitionBuilder
+
+        def builder: () -> DefinitionBuilder
+      end
+
+      def self.included: (Module) -> void
+
+      def env: () -> Environment
+
+      def builder: () -> DefinitionBuilder
+
+      @targets: Array[[target_type, Definition]]
+
+      def targets: () -> Array[[target_type, Definition]]
+
+      def target: () -> [target_type, Definition]
+
+      def testing: (String | target_type) ?{ () -> void } -> void
+
+      # The class object that is associated to the `instance` type of the testing type
+      #
+      def instance_class: () -> Class
+
+      # The singleton class object that is associated to the `class` type of the testing type
+      #
+      def class_class: () -> Class
+
+      def method_types: (Symbol) -> Array[MethodType]
+
+      def allows_error: (*Exception) { () -> void } -> void
+
+      # Calls a method `method_name` and validates if it's compatible with RBS type definition
+      #
+      # 1. It calls `method_name` with `receiver` passing `args` and given block,
+      # 2. Validates if it's compatible with given `method_type`, and
+      # 3. Validates if it's also compatible with one of the overloads defined in RBS type definition
+      #
+      # ```ruby
+      # assert_send_type(
+      #   "(::Integer) -> ::Integer",
+      #   [], :sum, 8
+      # )
+      # ```
+      #
+      # To test methods that takes a block, pass a block to `assert_send_type`.
+      # We recommend using `&proc { ... }` syntax for textual representation and prevent from using `break` from the block.
+      #
+      # ```ruby
+      # assert_send_type(
+      #   "() { () -> void } -> void",
+      #   self, :loop, &proc { break_from_block }
+      # )
+      # ```
+      #
+      # Exiting from the block using `break` and `return` skips assertions.
+      # Use `break_from_block` instead.
+      #
+      # `method_type` must be _simple_.
+      # It raises an exception if it's not _simple_.
+      # When you really need _non-simple_ `method_type`, wrap the calls inside `allow_non_simple_method_type`.
+      # See `docs/stdlib.md` for the details.
+      #
+      def assert_send_type: (String | MethodType method_type, untyped receiver, Symbol method_name, *untyped args) ?{ () -> untyped } -> void
+
+      # Calls a method `method_name` and validates if it's **not** compatible with RBS type definition
+      #
+      # 1. It calls `method_name` with `receiver` passing `args` and given block,
+      # 2. Validates if it's compatible with given `method_type`, and
+      # 3. Validates if it's not compatible with **none** of the overloads defined in RBS type definition
+      #
+      # See `assert_send_type` for the details.
+      #
+      def refute_send_type: (String | MethodType method_type, untyped receiver, Symbol method_name, *untyped args) ?{ () -> untyped } -> void
+
+      # Asserts if the constant `constant_name` has `constant_type`, and the RBS definition has compatible type
+      #
+      # ```ruby
+      # assert_const_type("Array[String]", "::Foo::Bar")
+      # ```
+      #
+      # The assertion above succeeds if `::Foo::Bar` is `["foo"]` and RBS contains `::Foo::Bar: [untyped]`.
+      # It fails if `::Foo::Bar` is `[2]`, or the RBS definition is `::Foo::Bar: String`.
+      #
+      def assert_const_type: (String | Types::t constant_type, String constant_name) -> void
+
+      # Asserts if given `value` has a type of `value_type`
+      #
+      def assert_type: (String | Types::t value_type, untyped value) -> void
+
+      # Allow non _simple-type_ method types given to `assert_send_type` and `refute_send_type`
+      #
+      # ```ruby
+      # allow_non_simple_method_type do
+      #   assert_send_type("() -> self", ...)
+      # end
+      # ```
+      #
+      def allow_non_simple_method_type: () { () -> void } -> void
+
+      @allows_non_simple_method_type: boolish
+
+      def validate_simple_method_type: (MethodType) -> void
+
+      # Break from `assert_send_type` or `refute_send_type`
+      #
+      def break_from_block: (?untyped value) -> void
+
+      @break_tag: untyped
+
+      def send_setup: [T] (String | RBS::MethodType method_type, untyped receiver, Symbol method_name, Array[untyped] args, Proc?) { (RBS::MethodType, Test::CallTrace, untyped, Exception?) -> T } -> T
+
+      def pass: (?String? message) -> void
+    end
+  end
+end

data/sig/unit_test/with_aliases.rbs

@@ -0,0 +1,136 @@
+module RBS
+  module UnitTest
+    # WithAliases module provides `with_***` methods that helps writing tests which passes convertible objects
+    #
+    # ```ruby
+    # include WithAliases
+    #
+    # with_int do |i|
+    #   # Yields Integer and RBS::UnitTest::Convertibles::ToInt
+    # end
+    #
+    # with_string.and_nil do |s|
+    #   # Yields String, RBS::UnitTest::Convertibles::ToStr, and nil
+    # end
+    # ```
+    #
+    module WithAliases
+      include Convertibles
+
+      class WithEnum[T]
+        @enum: _Each[T]
+
+        include Enumerable[T]
+
+        def initialize: (_Each[T] enum) -> void
+
+        def each: () { (T) -> void } -> void
+
+        # Yield `nil` in addition to original `enum` elements
+        #
+        # ```ruby
+        # e = WithEnum.new([1, 2])
+        # e.and_nil do |i|
+        #   pp i     # => 1, 2, and nil
+        # end
+        # ```
+        #
+        def and_nil: () { (T?) -> void } -> void
+                   | () -> WithEnum[T?]
+
+        # Skip yielding objects in `cases`
+        #
+        # ```ruby
+        # e = WithEnum.new([1, 2, 3])
+        # e.but(2) do |i|
+        #   pp i     # => 1 and 3
+        # end
+        # ```
+        #
+        def but: (*T cases) { (T) -> void } -> void
+               | (*T cases) -> WithEnum[T]
+
+        # Yield objects in `args` in addition to original `enum` elements
+        #
+        # ```ruby
+        # e = WithEnum.new([1, 2])
+        # e.and(3) do |i|
+        #   pp i     # => 1, 2, and 3
+        # end
+        # ```
+        #
+        def and: [S] (*S args) { (T | S) -> void } -> void
+               | [S] (*S args) -> WithEnum[T | S]
+      end
+
+      # Yields `args` objects
+      #
+      def with: (*untyped args) -> void
+              | (*untyped args) { (untyped) -> void } -> void
+
+      # Yields `::int` objects
+      #
+      def with_int: (?Integer value) { (int) -> void } -> void
+                  | (?Integer value) -> WithEnum[int]
+
+      # Yields `::float` objects
+      #
+      def with_float: (?Float value) { (float) -> void } -> void
+                    | (?Float value) -> WithEnum[float]
+
+      # Yields `::string` objects
+      #
+      def with_string: (?String value) { (string) -> void } -> void
+                     | (?String value) -> WithEnum[string]
+
+      # Yields `::array` objects
+      #
+      def with_array: [T] (*T elements) { (array[T]) -> void } -> void
+                    | [T] (*T elements) -> WithEnum[array[T]]
+
+      # Yields `::hash` objects
+      #
+      def with_hash: [K, V] (?Hash[K, V] hash) { (hash[K, V]) -> void } -> void
+                   | [K, V] (?Hash[K, V] hash) -> WithEnum[hash[K, V]]
+
+      # Yields `::io` objects
+      #
+      def with_io: (?untyped io) { (io) -> void } -> void
+                 | (?untyped io) -> WithEnum[io]
+
+      # Yields `::path` objects
+      #
+      def with_path: (?String path) { (path) -> void } -> void
+                   | (?String path) -> WithEnum[path]
+
+      # Yields `::encoding` objects
+      #
+      def with_encoding: (?untyped encoding) { (encoding) -> void } -> void
+                       | (?untyped encoding) -> WithEnum[encoding]
+
+      # Yields `::interned` objects
+      #
+      def with_interned: (?Symbol value) { (interned) -> void } -> void
+                       | (?Symbol value) -> WithEnum[interned]
+
+      # Yields `::bool` objects
+      #
+      def with_bool: () { (bool) -> void } -> void
+                   | () -> WithEnum[bool]
+
+      # Yields `::boolish` objects
+      #
+      def with_boolish: () { (boolish) -> void } -> void
+                      | () -> WithEnum[boolish]
+
+      # Yields `::untyped` objects
+      #
+      def with_untyped: () { (untyped) -> void } -> void
+                      | () -> WithEnum[untyped]
+
+      # Yields `::range` objects
+      #
+      def with_range: (WithEnum[untyped] start, WithEnum[untyped] stop, ?bool exclude_end) { (range[untyped]) -> void } -> void
+    end
+  end
+end

data/sig/use_map.rbs

@@ -0,0 +1,35 @@
+module RBS
+  class Environment
+    # ```rb
+    # map = UseMap.build(environment)
+    #
+    # map.resolve?(TypeName.parse("TN"))   # => nil or resolved type name
+    # ```
+    #
+    class UseMap
+      class Table
+        attr_reader known_types: Set[TypeName]
+
+        attr_reader children: Hash[Namespace, Set[TypeName]]
+
+        def initialize: () -> void
+
+        def compute_children: () -> self
+      end
+
+      attr_reader use_dirs: Array[AST::Directives::Use]
+
+      @map: Hash[Symbol, TypeName]
+
+      @table: Table
+
+      def initialize: (table: Table) -> void
+
+      def resolve?: (TypeName) -> TypeName?
+
+      def resolve: (TypeName) -> TypeName
+
+      def build_map: (AST::Directives::Use::clause) -> self
+    end
+  end
+end

data/sig/validator.rbs

@@ -2,7 +2,7 @@ module RBS
   class Validator
     attr_reader env: Environment
 
-    attr_reader resolver: TypeNameResolver
+    attr_reader resolver: Resolver::TypeNameResolver?
 
     attr_reader definition_builder: DefinitionBuilder
 
@@ -10,11 +10,11 @@ module RBS
 
     attr_reader type_alias_regularity: TypeAliasRegularity
 
-    def initialize: (env: Environment, resolver: TypeNameResolver) -> void
+    def initialize: (env: Environment, ?resolver: Resolver::TypeNameResolver?) -> void
 
     # Validates the presence of type names and type application arity match.
     #
-    def validate_type: (Types::t, context: TypeNameResolver::context) -> void
+    def validate_type: (Types::t, context: Resolver::context) -> void
 
     # Validates type alias definition:
     #
@@ -25,7 +25,7 @@ module RBS
     #
     # It yields the rhs type if block is given, so that you can validate the rhs type.
     #
-    def validate_type_alias: (entry: Environment::SingleEntry[TypeName, AST::Declarations::Alias]) ?{ (Types::t rhs_type) -> void } -> void
+    def validate_type_alias: (entry: Environment::TypeAliasEntry) ?{ (Types::t rhs_type) -> void } -> void
 
     # Validates the type parameters in generic methods.
     #
@@ -42,11 +42,18 @@ module RBS
     #
     def validate_type_params: (Array[AST::TypeParam] params, type_name: TypeName, ?method_name: Symbol?, location: Location[untyped, untyped]?) -> void
 
+    # Validates class alias declaration
+    #
+    # - The right hand side can be normalized
+    # - No mixing alias declaration between class and modules
+    #
+    def validate_class_alias: (entry: Environment::ClassAliasEntry | Environment::ModuleAliasEntry) -> void
+
     private
 
     # Resolves relative type names to absolute type names in given context.
     # Yields the type when the type name resolution using `#resolver` fails.
     #
-    def absolute_type: (Types::t, context: TypeNameResolver::context) { (Types::t) -> TypeName } -> Types::t
+    def absolute_type: (Types::t, context: Resolver::context) ?{ (Types::t) -> TypeName } -> Types::t
   end
 end

data/sig/variance_calculator.rbs

@@ -72,13 +72,15 @@ module RBS
 
     def in_inherit: (name: TypeName, args: Array[Types::t], variables: Array[Symbol]) -> Result
 
+    # The type name must be normalized
+    #
     def in_type_alias: (name: TypeName) -> Result
 
     private
 
     def type: (Types::t, result: Result, context: variance) -> void
 
-    def function: (Types::Function, result: Result, context: variance) -> void
+    def function: (Types::function, result: Result, context: variance) -> void
 
     def negate: (variance) -> variance
   end

data/sig/vendorer.rbs

@@ -24,7 +24,7 @@ module RBS
   # vendor/rbs/minitest-1.2.3  => Will include `minitest` library RBSs.
   # ```
   #
-  # The vendorerd RBSs will be loaded through :dir source.
+  # The vendored RBSs will be loaded through :dir source.
   #
   # ```rb
   # loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: true))

data/sig/visitor.rbs

@@ -0,0 +1,47 @@
+module RBS
+  module AST
+    class Visitor
+      def visit_all: (Enumerable[(Members::Base | Declarations::Base)] nodes) -> void
+
+      def visit: ((Members::Base | Declarations::Base) node) -> void
+
+      def visit_declaration_global: (Declarations::Global node) -> void
+
+      def visit_declaration_class: (Declarations::Class node) -> void
+
+      def visit_declaration_module: (Declarations::Module node) -> void
+
+      def visit_declaration_constant: (Declarations::Constant node) -> void
+
+      def visit_declaration_type_alias: (Declarations::TypeAlias node) -> void
+
+      def visit_declaration_interface: (Declarations::Interface node) -> void
+
+      def visit_member_alias: (Members::Alias node) -> void
+
+      def visit_member_class_instance_variable: (Members::ClassInstanceVariable node) -> void
+
+      def visit_member_class_variable: (Members::ClassVariable node) -> void
+
+      def visit_member_instance_variable: (Members::InstanceVariable node) -> void
+
+      def visit_member_private: (Members::Private node) -> void
+
+      def visit_member_public: (Members::Public node) -> void
+
+      def visit_member_method_definition: (Members::MethodDefinition node) -> void
+
+      def visit_member_attr_reader: (Members::AttrReader node) -> void
+
+      def visit_member_attr_writer: (Members::AttrWriter node) -> void
+
+      def visit_member_attr_accessor: (Members::AttrAccessor node) -> void
+
+      def visit_member_include: (Members::Include node) -> void
+
+      def visit_member_prepend: (Members::Prepend node) -> void
+
+      def visit_member_extend: (Members::Extend node) -> void
+    end
+  end
+end

data/sig/writer.rbs

@@ -21,7 +21,7 @@ module RBS
     # Output the array of declarations.
     # It automatically inserts empty lines between the declarations.
     #
-    def write: (Array[AST::Declarations::t]) -> void
+    def write: (Array[AST::Declarations::t | AST::Directives::t]) -> void
 
     def preserve?: () -> bool
 
@@ -94,6 +94,10 @@ module RBS
 
     def write_loc_source: (_Located) { () -> void } -> void
 
+    def format_annotation: (AST::Annotation) -> String
+
+    def write_directive: (AST::Directives::t) -> void
+
     def write_annotation: (Array[AST::Annotation]) -> void
 
     def write_comment: (AST::Comment?) -> void
@@ -106,7 +110,7 @@ module RBS
 
     def name_and_args: (TypeName, Array[Types::t]) -> String?
 
-    def write_alias: (AST::Declarations::Alias) -> void
+    def write_alias: (AST::Declarations::TypeAlias) -> void
 
     def method_name: (Symbol) -> String