rbs 2.8.4 → 3.8.1

data/sig/sorter.rbs

@@ -14,10 +14,28 @@ module RBS
 
     def run: () -> void
 
-    def group: (member member) -> Numeric
-
-    def key: (member member) -> String
-
-    def sort_decl!: (AST::Declarations::t decl) -> void
+    type partitioned = {
+      type_alias_decls: Array[AST::Declarations::TypeAlias],
+      constant_decls: Array[AST::Declarations::Constant],
+      class_decls: Array[AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface],
+      mixin_includes: Array[AST::Members::Include],
+      mixin_prepends: Array[AST::Members::Prepend],
+      mixin_extends: Array[AST::Members::Extend],
+      class_variables: Array[AST::Members::ClassVariable],
+      class_instance_variables: Array[AST::Members::ClassInstanceVariable],
+      instance_variables: Array[AST::Members::InstanceVariable],
+      singleton_attributes: Array[AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader],
+      instance_attributes: Array[AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader],
+      module_functions: Array[AST::Members::MethodDefinition],
+      singleton_new_methods: Array[AST::Members::MethodDefinition],
+      public_singleton_methods: Array[AST::Members::MethodDefinition | AST::Members::Alias],
+      private_singleton_methods: Array[AST::Members::MethodDefinition],
+      instance_initialize_methods: Array[AST::Members::MethodDefinition],
+      public_instance_methods: Array[AST::Members::MethodDefinition | AST::Members::Alias],
+      private_instance_methods: Array[AST::Members::MethodDefinition],
+      other_decls: Array[member]
+    }
+
+    def sort_decl: (member decl) -> member
   end
 end

data/sig/substitution.rbs

@@ -38,5 +38,11 @@ module RBS
 
     # Returns true if given substitution is identity.
     def empty?: () -> bool
+
+    alias [] apply
+
+    # (s1 + s2)[t] == s2[s1[t]]
+    # 
+    def +: (Substitution) -> Substitution
   end
 end

data/sig/subtractor.rbs

@@ -0,0 +1,37 @@
+module RBS
+  class Subtractor
+    type decl_with_members = AST::Declarations::Class | AST::Declarations::Module
+
+    @minuend: Array[AST::Declarations::t]
+    @subtrahend: Environment
+
+    def initialize: (Array[AST::Declarations::t] minuend, Environment subtrahend) -> void
+
+    def call: (?Array[AST::Declarations::t], ?context: Resolver::context) -> Array[AST::Declarations::t]
+
+    private def filter_members: (decl_with_members, context: Resolver::context) -> decl_with_members?
+
+    private def member_exist?: (TypeName owner, AST::Members::t, context: Resolver::context) -> boolish
+
+    private def method_exist?: (TypeName owner, Symbol method_name, AST::Members::MethodDefinition::kind) -> boolish
+
+    private def ivar_exist?: (TypeName owner, Symbol ivar_name, AST::Members::Attribute::kind) -> boolish
+
+    private def cvar_exist?: (TypeName owner, Symbol cvar_name) -> boolish
+
+    private def each_member: (TypeName owner) { (AST::Members::t | AST::Declarations::t) -> void } -> void
+                           | (TypeName owner) -> Enumerator[(AST::Members::t | AST::Declarations::t), void]
+
+    private def mixin_exist?: (TypeName owner, AST::Members::Include | AST::Members::Extend | AST::Members::Prepend, context: Resolver::context) -> boolish
+
+    private def filter_redundunt_access_modifiers: (Array[AST::Declarations::t | AST::Members::t]) -> Array[AST::Declarations::t | AST::Members::t]
+
+    private def access_modifier?: (AST::Declarations::t | AST::Members::t?) -> bool
+
+    private def update_decl: (decl_with_members, members: Array[AST::Declarations::t | AST::Members::t]) -> decl_with_members
+
+    private def absolute_typename: (TypeName, context: Resolver::context) -> TypeName
+
+    private def typename_candidates: (TypeName, context: Resolver::context) -> Array[TypeName]
+  end
+end

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

data/sig/test.rbs

@@ -0,0 +1,82 @@
+module RBS
+  module Test
+    # Object#class
+    CLASS: UnboundMethod
+
+    # Module#define_method
+    DEFINE_METHOD: UnboundMethod
+
+    # Kernel#inspect
+    INSPECT: UnboundMethod
+
+    # BasicObject#instance_eval
+    INSTANCE_EVAL: UnboundMethod
+
+    # BasicObject#instance_exec
+    INSTANCE_EXEC: UnboundMethod
+
+    # Kernel#is_a?
+    IS_AP: UnboundMethod
+
+    # Kernel#method
+    METHOD: UnboundMethod
+
+    # Kernel#methods
+    METHODS: UnboundMethod
+
+    # Kernel#pp
+    PP: UnboundMethod
+
+    # Kernel#singleton_class
+    SINGLETON_CLASS: UnboundMethod
+
+    # Kernel#respond_to?
+    RESPOND_TOP: UnboundMethod
+
+    class ArgumentsReturn
+      type exit_type = :return | :exception | :break
+
+      attr_reader arguments: Array[untyped]
+
+      attr_reader exit_value: untyped
+
+      attr_reader exit_type: exit_type
+
+      def initialize: (arguments: Array[untyped], exit_value: untyped, exit_type: exit_type) -> void
+
+      def self.return: (arguments: Array[untyped], value: untyped) -> ArgumentsReturn
+
+      def self.exception: (arguments: Array[untyped], exception: untyped) -> ArgumentsReturn
+
+      def self.break: (arguments: Array[untyped]) -> ArgumentsReturn
+
+      def return_value: () -> untyped
+
+      def exception: () -> untyped
+
+      def return?: () -> bool
+
+      def exception?: () -> bool
+
+      def break?: () -> bool
+    end
+
+    class CallTrace
+      attr_reader method_name: Symbol
+
+      attr_reader method_call: ArgumentsReturn
+
+      attr_reader block_calls: Array[ArgumentsReturn]
+
+      attr_reader block_given: bool
+
+      def initialize: (method_name: Symbol, method_call: ArgumentsReturn, block_calls: Array[ArgumentsReturn], block_given: bool) -> void
+    end
+
+    attr_accessor self.suffix: String
+
+    def self.reset_suffix: () -> String
+
+    def self.call: (untyped receiver, UnboundMethod, *untyped) ?{ () -> void } -> void
+  end
+end

data/sig/type_alias_dependency.rbs

@@ -1,14 +1,45 @@
 module RBS
+  # TypeAliasDependency calculates the dependencies between type aliases
+  #
+  # The dependencies are normalized automatically.
+  #
   class TypeAliasDependency
     attr_reader env: Environment
 
+    # A hash table from type alias name to it's direct dependencies
+    #
+    # The source type name and dependencies are normalized.
+    #
     attr_reader direct_dependencies: Hash[TypeName, Set[TypeName]]
+
+    # A hash table from type alias name to a hash name with keys of transitive dependencies
+    #
+    # The source type name and dependencies are normalized.
+    #
     attr_reader dependencies: Hash[TypeName, Hash[TypeName, bool]]
 
     def initialize: (env: Environment) -> void
 
+    # Returns `true` if given type alias is circular
+    #
+    # Normalized given type name automatically.
+    #
     def circular_definition?: (TypeName alias_name) -> bool
 
+    # Returns the set of direct dependencies from the given type name
+    #
+    # Given type name will be normalized automatically.
+    # Returns normalized type names.
+    #
+    def direct_dependencies_of: (TypeName) -> Set[TypeName]
+
+    # Returns the set of dependencies from the given type name
+    #
+    # Given type name will be normalized automatically.
+    # Returns normalized type names.
+    #
+    def dependencies_of: (TypeName) -> Set[TypeName]
+
     def build_dependencies: () -> void
 
     def transitive_closure: () -> void

data/sig/type_alias_regularity.rbs

@@ -20,9 +20,9 @@ module RBS
   # ```rb
   # validator = RBS::TypeAliasRegularity.validate(env: env)
   #
-  # validator.nonregular?(TypeName("::foo"))    # => nil
-  # validator.nonregular?(TypeName("::bar"))    # => nil
-  # validator.nonregular?(TypeName("::baz"))    # => TypeAliasRegularity::Diagnostic
+  # validator.nonregular?(TypeName.parse("::foo"))    # => nil
+  # validator.nonregular?(TypeName.parse("::bar"))    # => nil
+  # validator.nonregular?(TypeName.parse("::baz"))    # => TypeAliasRegularity::Diagnostic
   # ```
   #
   # A special case is when the type argument is `untyped`.
@@ -36,6 +36,9 @@ module RBS
 
     attr_reader builder: DefinitionBuilder
 
+    # Diagnostics of each type aliases.
+    # The type names are normalized.
+    #
     attr_reader diagnostics: Hash[TypeName, Diagnostic]
 
     # `Diagnostic` represents an non-regular type alias declaration error.
@@ -48,8 +51,8 @@ module RBS
     # The type `t` is nonregular because it contains `t[T?]` on it's right hand side.
     #
     # ```
-    # diagnostic = validator.nonregular?(TypeName("::t"))
-    # diagnostic.type_name         # => TypeName("::t")
+    # diagnostic = validator.nonregular?(TypeName.parse("::t"))
+    # diagnostic.type_name         # => TypeName.parse("::t")
     # diagnostic.nonregular_type   # => t[T?]
     # ```
     #
@@ -68,7 +71,9 @@ module RBS
     def initialize: (env: Environment) -> void
 
     # Returns `Diagnostic` instance if the alias type is nonregular.
-    # Regurns `nil` if the alias type is regular.
+    # Returns `nil` if the alias type is regular.
+    #
+    # Normalizes the given type name automatically.
     #
     def nonregular?: (TypeName) -> Diagnostic?
 
@@ -87,6 +92,7 @@ module RBS
 
     def each_alias_type: (Types::t) { (Types::Alias) -> void } -> void
 
+    # Yields set of normalized type names
     def each_mutual_alias_defs: () { (Set[TypeName]) -> void } -> void
   end
 end

data/sig/type_param.rbs

@@ -4,12 +4,13 @@ module RBS
       # Key
       # ^^^ name
       #
-      # unchecked out Elem < _ToJson
-      # ^^^^^^^^^                    unchecked
-      #           ^^^                variance
-      #               ^^^^           name
-      #                    ^^^^^^^^^ upper_bound
-      type loc = Location[:name, :variance | :unchecked | :upper_bound]
+      # unchecked out Elem < _ToJson = untyped
+      # ^^^^^^^^^                                 unchecked
+      #           ^^^                             variance
+      #               ^^^^                        name
+      #                    ^^^^^^^^^              upper_bound
+      #                              ^^^^^^^^^    default
+      type loc = Location[:name, :variance | :unchecked | :upper_bound | :default]
 
       type variance = :invariant | :covariant | :contravariant
 
@@ -19,9 +20,13 @@ module RBS
       attr_reader variance: variance
       attr_reader location: loc?
 
-      attr_reader upper_bound: bound?
+      %a{pure} def upper_bound: () -> bound?
 
-      def initialize: (name: Symbol, variance: variance, upper_bound: bound?, location: loc?) -> void
+      attr_reader upper_bound_type: Types::t?
+
+      attr_reader default_type: Types::t?
+
+      def initialize: (name: Symbol, variance: variance, upper_bound: Types::t?, location: loc?, ?default_type: Types::t?) -> void
 
       include _ToJson
 
@@ -37,7 +42,7 @@ module RBS
 
       def unchecked?: () -> bool
 
-      def map_type: () { (bound) -> bound } -> TypeParam
+      def map_type: () { (Types::t) -> Types::t } -> TypeParam
 
       # Helper function to resolve _class instance types_ to _type variables_.
       #
@@ -69,6 +74,37 @@ module RBS
       def self.rename: (Array[TypeParam], new_names: Array[Symbol]) -> Array[TypeParam]
 
       def to_s: () -> String
+
+      # Validates TypeParams if it refers another optional type params
+      #
+      # * Returns array of TypeParam objects that refers other optional type params
+      # * Returns `nil` if all type params are valid
+      #
+      def self.validate: (Array[TypeParam]) -> Array[TypeParam]?
+
+      # Returns an application with respect to type params' default
+      #
+      def self.application: (Array[TypeParam], Array[Types::t]) -> Substitution?
+
+      # Returns an array of type args, that fills omitted types with the defaults
+      #
+      # ```rbs
+      # interface _Foo[T, S = untyped]
+      # end
+      # ```
+      #
+      # Normalizing type args with `_Foo` works as following:
+      #
+      # ```rbs
+      # _Foo[String]                   # => _Foo[String, untyped]
+      # _Foo[String, Integer]          # => _Foo[String, Integer]
+      # _Foo                           # => _Foo                            (Omitting missing args)
+      # _Foo[String, Integer, untyped] # => _Foo[String, Integer, untyped]  (Keeping extra args)
+      # ```
+      #
+      # Note that it allows invalid arities, returning the `args` immediately.
+      #
+      def self.normalize_args: (Array[TypeParam], Array[Types::t]) -> Array[Types::t]
     end
   end
 end

data/sig/typename.rbs

@@ -57,9 +57,9 @@ module RBS
     # Returns a new type name with a namespace appended to given namespace.
     #
     # ```rb
-    # TypeName("Hello").with_prefix(Namespace("World"))           # => World::Hello
-    # TypeName("Foo::Bar").with_prefix(Namespace("::Hello"))      # => ::Hello::Foo::Bar
-    # TypeName("::A::B").with_prefix(Namespace("C"))              # => ::A::B
+    # TypeName.parse("Hello").with_prefix(Namespace("World"))           # => World::Hello
+    # TypeName.parse("Foo::Bar").with_prefix(Namespace("::Hello"))      # => ::Hello::Foo::Bar
+    # TypeName.parse("::A::B").with_prefix(Namespace("C"))              # => ::A::B
     # ```
     #
     def with_prefix: (Namespace namespace) -> TypeName
@@ -67,10 +67,13 @@ module RBS
     def +: (TypeName) -> TypeName
 
     def split: () -> Array[Symbol]
+
+    # Returns type name with given string representation.
+    def self.parse: (String name) -> RBS::TypeName
   end
 end
 
 module Kernel
-  # Returns type name with given string representation.
-  def TypeName: (String name) -> RBS::TypeName
+  # Deprecated: Use `RBS::TypeName.parse` instead
+  %a{steep:deprecated} def TypeName: (String name) -> RBS::TypeName
 end

data/sig/types.rbs

@@ -18,9 +18,11 @@ module RBS
       # Yields all direct sub types included in the type.
       # It doesn't yield the type itself.
       #
-      #   parse("Hash[String, Array[Symbol]]").each_type do |ty|
-      #     ...       # Yields String and Array[Symbol]
-      #   end
+      # ```ruby
+      # parse("Hash[String, Array[Symbol]]").each_type do |ty|
+      #   ...       # Yields String and Array[Symbol]
+      # end
+      # ```
       #
       def each_type: () { (t) -> void } -> void
                    | () -> Enumerator[t, void]
@@ -32,11 +34,27 @@ module RBS
       # Returns a String representation.
       # `level` is used internally.
       #
-      #   parse("String").to_s               # => "String"
-      #   parse("String | Integer").to_s()   # => "String | Integer"
-      #   parse("String | Integer").to_s(1)  # => "(String | Integer)"
+      # ```ruby
+      # parse("String").to_s               # => "String"
+      # parse("String | Integer").to_s()   # => "String | Integer"
+      # parse("String | Integer").to_s(1)  # => "(String | Integer)"
+      # ```
       #
       def to_s: (?Integer level) -> String
+
+      # Returns `true` if it has `self` type
+      #
+      def has_self_type?: () -> bool
+
+      # Returns `true` if it has `instance` or `class` types
+      def has_classish_type?: () -> bool
+
+      # Returns `true` if it has `void` types other than *return* position
+      #
+      # * The function return type is a return position (`() -> void`)
+      # * Generic parameter is a return position (`Enumerator[Integer, void]`)
+      #
+      def with_nonreturn_void?: () -> bool
     end
 
     # t represents union of all possible types.
@@ -93,6 +111,9 @@ module RBS
       end
 
       class Any < Base
+        @string: String?
+
+        def todo!: () -> self
       end
 
       class Nil < Base
@@ -187,6 +208,12 @@ module RBS
 
       def each_type: () { (t) -> void } -> void
                    | () -> Enumerator[t, void]
+
+      def has_self_type?: () -> bool
+
+      def has_classish_type?: () -> bool
+
+      def with_nonreturn_void?: () -> bool
     end
 
     class Interface
@@ -274,11 +301,23 @@ module RBS
     end
 
     class Record
-      attr_reader fields: Hash[Symbol, t]
+      type key = Symbol | String | Integer | bool
+
+      # All types of all files
+      #
+      # If the key is *required*, the second value of the tuple is `true`.
+      # If the key is *optional*, the second value of the tuple is `false`.
+      #
+      attr_reader all_fields: Hash[key, [t, bool]]
+
+      attr_reader fields: Hash[key, t]
+
+      attr_reader optional_fields: Hash[key, t]
 
       type loc = Location[bot, bot]
 
-      def initialize: (fields: Hash[Symbol, t], location: loc?) -> void
+      def initialize: (fields: Hash[key, t], location: loc?) -> void
+                    | (all_fields: Hash[key, [t, bool]], location: loc?) -> void
 
       include _TypeBase
 
@@ -408,15 +447,78 @@ module RBS
       def amap: [A, B] (Array[A]) { (A) -> B } -> Array[B]
 
       def hmapv: [X, Y, Z] (Hash[X, Y]) { (Y) -> Z } -> Hash[X, Z]
+
+      def has_self_type?: () -> bool
+
+      def has_classish_type?: () -> bool
+
+      def with_nonreturn_void?: () -> bool
+
+      def ==: (untyped) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
+    end
+
+    # Function type without type checking arguments
+    #
+    class UntypedFunction
+      attr_reader return_type: t
+
+      def initialize: (return_type: t) -> void
+
+      def free_variables: (?Set[Symbol]) -> Set[Symbol]
+
+      def map_type: { (t) -> t } -> UntypedFunction
+                  | -> Enumerator[t, UntypedFunction]
+
+      def map_type_name: () { (TypeName, Location[untyped, untyped]?, t) -> TypeName } -> UntypedFunction
+
+      def each_type: () { (t) -> void } -> void
+                   | -> Enumerator[t, void]
+
+      def each_param: () { (Function::Param) -> void } -> void
+                    | -> Enumerator[Function::Param, void]
+
+      include _ToJson
+
+      def sub: (Substitution) -> UntypedFunction
+
+      def with_return_type: (t) -> UntypedFunction
+
+      def update: (?return_type: t) -> UntypedFunction
+
+      def empty?: () -> bool
+
+      def has_self_type?: () -> bool
+
+      def has_classish_type?: () -> bool
+
+      def with_nonreturn_void?: () -> bool
+
+      # Returns `?`
+      def param_to_s: () -> String
+
+      # Returns `return_type.to_s(1)`
+      def return_to_s: () -> String
+
+      def ==: (untyped) -> bool
+
+      alias eql? ==
+
+      def hash: () -> Integer
     end
 
+    type function = Types::Function | Types::UntypedFunction
+
     class Block
-      attr_reader type: Types::Function
+      attr_reader type: function
       attr_reader required: bool
 
       attr_reader self_type: t?
 
-      def initialize: (type: Types::Function, ?self_type: t?, required: boolish) -> void
+      def initialize: (type: function, ?self_type: t?, required: boolish) -> void
 
       def ==: (untyped other) -> bool
 
@@ -432,14 +534,14 @@ module RBS
     end
 
     class Proc
-      attr_reader type: Function
+      attr_reader type: function
       attr_reader block: Block?
 
       attr_reader self_type: t?
 
       type loc = Location[bot, bot]
 
-      def initialize: (location: loc?, type: Function, ?self_type: t?, block: Block?) -> void
+      def initialize: (location: loc?, type: function, ?self_type: t?, block: Block?) -> void
 
       include _TypeBase
 
@@ -464,6 +566,11 @@ module RBS
       include NoTypeName
 
       attr_reader location: loc?
+
+      TABLE: Hash[String, String]
+
+      # Unescape string type body
+      def self.unescape_string: (String, bool is_double_quote) -> String
     end
   end
 end