rbs 1.8.0 → 2.0.0

data/sig/declarations.rbs

@@ -6,56 +6,6 @@ module RBS
       class Base
       end
 
-      type variance = :invariant | :covariant | :contravariant
-
-      class ModuleTypeParams
-        class TypeParam
-          # Key
-          # ^^^ name
-          #
-          # unchecked out Elem
-          # ^^^^^^^^^          unchecked
-          #           ^^^      variance
-          #               ^^^^ name
-          type loc = Location[:name, :variance | :unchecked]
-
-          attr_reader name: Symbol
-          attr_reader variance: variance
-          attr_reader skip_validation: bool
-          attr_reader location: loc?
-
-          def initialize: (name: Symbol, variance: variance, skip_validation: boolish, location: loc?) -> void
-
-          include _ToJson
-        end
-
-        attr_reader params: Array[TypeParam]
-
-        def initialize: () -> void
-
-        def add: (TypeParam param) -> self
-
-        include _HashEqual
-        include _ToJson
-
-        def []: (Symbol) -> TypeParam?
-
-        def each: { (TypeParam) -> void } -> void
-                | () -> Enumerator[TypeParam, void]
-
-        def self.empty: () -> instance
-
-        def variance: (Symbol) -> variance
-
-        def skip_validation?: (Symbol) -> bool
-
-        def empty?: () -> bool
-
-        def size: () -> Integer
-
-        def rename_to: (Array[Symbol] names) -> ModuleTypeParams
-      end
-
       interface _WithMember
         def members: () -> Array[untyped]
       end
@@ -118,14 +68,14 @@ module RBS
         include MixinHelper
 
         attr_reader name: TypeName
-        attr_reader type_params: ModuleTypeParams
+        attr_reader type_params: Array[TypeParam]
         attr_reader members: Array[member]
         attr_reader super_class: Super?
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
 
-        def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], super_class: Super?, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], super_class: Super?, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -172,14 +122,14 @@ module RBS
         include MixinHelper
 
         attr_reader name: TypeName
-        attr_reader type_params: ModuleTypeParams
+        attr_reader type_params: Array[TypeParam]
         attr_reader members: Array[member]
         attr_reader location: loc?
         attr_reader annotations: Array[Annotation]
         attr_reader self_types: Array[Self]
         attr_reader comment: Comment?
 
-        def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], location: loc?, annotations: Array[Annotation], self_types: Array[Self], comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], location: loc?, annotations: Array[Annotation], self_types: Array[Self], comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -202,13 +152,13 @@ module RBS
         type loc = Location[:name | :keyword | :end, :type_params]
 
         attr_reader name: TypeName
-        attr_reader type_params: ModuleTypeParams
+        attr_reader type_params: Array[TypeParam]
         attr_reader members: Array[member]
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
 
-        def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
         include MixinHelper
 
@@ -226,13 +176,13 @@ module RBS
         type loc = Location[:keyword | :name | :eq, :type_params]
 
         attr_reader name: TypeName
-        attr_reader type_params: ModuleTypeParams
+        attr_reader type_params: Array[TypeParam]
         attr_reader type: Types::t
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
 
-        def initialize: (name: TypeName, type_params: ModuleTypeParams, type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: Array[TypeParam], type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson

data/sig/definition.rbs

@@ -54,10 +54,20 @@ module RBS
 
       def private?: () -> bool
 
+      # Substitutes type variables to some types.
+      # Takes care of type parameter bounds.
+      #
       def sub: (Substitution) -> Method
 
+      # Applies the mapping from `Types::t` to `Types::t`.
+      #
+      # Note this method doesn't handle upper bound in type params.
+      # You may want to use `#map_type_bound` explicitly, or `#sub` for simple substitution.
+      #
       def map_type: () { (Types::t) -> Types::t } -> Method
 
+      def map_type_bound: () { (AST::TypeParam::bound) -> AST::TypeParam::bound } -> Method
+
       def map_method_type: () { (MethodType) -> MethodType } -> Method
     end
 
@@ -127,7 +137,7 @@ module RBS
 
     def type_params: () -> Array[Symbol]
 
-    def type_params_decl: () -> AST::Declarations::ModuleTypeParams
+    def type_params_decl: () -> Array[AST::TypeParam]
 
     def sub: (Substitution) -> Definition
 

data/sig/definition_builder.rbs

@@ -33,7 +33,7 @@ module RBS
     def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
                  | [A] (TypeName, cache: Hash[A, Definition | false | nil], key: A) { () -> Definition } -> Definition
 
-    def validate_params_with: (AST::Declarations::ModuleTypeParams, result: VarianceCalculator::Result) { (AST::Declarations::ModuleTypeParams::TypeParam) -> void } -> void
+    def validate_params_with: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void
 
     def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
 
@@ -43,6 +43,13 @@ module RBS
 
     def define_methods: (Definition, interface_methods: Hash[Symbol, Definition::Method], methods: MethodBuilder::Methods, super_interface_method: bool) -> void
 
+    # Validates presence of type names recursively.
+    # Assumes the type names are already resolved.
+    #
+    def validate_type_presence: (Types::t) -> void
+
+    def validate_type_name: (TypeName, Location[untyped, untyped]?) -> void
+
     # Expand a type alias of given name without type arguments.
     # Raises an error if the type alias requires arguments.
     #

data/sig/environment.rbs

@@ -31,7 +31,9 @@ module RBS
 
       def validate_type_params: () -> void
 
-      def type_params: () -> AST::Declarations::ModuleTypeParams
+      def compatible_params?: (Array[AST::TypeParam], Array[AST::TypeParam]) -> boolish
+
+      def type_params: () -> Array[AST::TypeParam]
 
       def primary: () -> D[module_decl]
     end
@@ -96,6 +98,10 @@ module RBS
 
     def resolve_member: (TypeNameResolver, AST::Members::t, context: Array[Namespace]) -> AST::Members::t
 
+    def resolve_method_type: (TypeNameResolver, RBS::MethodType, context: Array[Namespace]) -> RBS::MethodType
+
+    def resolve_type_params: (TypeNameResolver resolver, Array[AST::TypeParam], context: Array[Namespace]) ->  Array[AST::TypeParam]
+
     def absolute_type: (TypeNameResolver, Types::t, context: Array[Namespace]) -> Types::t
 
     def absolute_type_name: (TypeNameResolver, TypeName, context: Array[Namespace]) -> TypeName

data/sig/errors.rbs

@@ -179,10 +179,10 @@ module RBS
 
   class InvalidVarianceAnnotationError < DefinitionError
     attr_reader type_name: TypeName
-    attr_reader param: AST::Declarations::ModuleTypeParams::TypeParam
+    attr_reader param: AST::TypeParam
     attr_reader location: Location[untyped, untyped]?
 
-    def initialize: (type_name: TypeName, param: AST::Declarations::ModuleTypeParams::TypeParam, location: Location[untyped, untyped]?) -> void
+    def initialize: (type_name: TypeName, param: AST::TypeParam, location: Location[untyped, untyped]?) -> void
   end
 
   class RecursiveAliasDefinitionError < DefinitionError
@@ -212,7 +212,7 @@ module RBS
     def mixin_name: () -> String
   end
 
-  class RecursiveTypeAliasError < LoadingError
+  class RecursiveTypeAliasError < BaseError
     attr_reader alias_names: Array[TypeName]
     attr_reader location: Location[untyped, untyped]?
 
@@ -221,7 +221,7 @@ module RBS
     def name: () -> String
   end
 
-  class NonregularTypeAliasError < LoadingError
+  class NonregularTypeAliasError < BaseError
     # Diagnostic reported from `TypeAliasRegularity`.
     attr_reader diagnostic: TypeAliasRegularity::Diagnostic
 
@@ -230,4 +230,19 @@ module RBS
 
     def initialize: (diagnostic: TypeAliasRegularity::Diagnostic, location: Location[untyped, untyped]?) -> void
   end
+
+  class CyclicTypeParameterBound < BaseError
+    attr_reader location: Location[untyped, untyped]?
+
+    # Array of parameters which contains cyclic dependencies.
+    attr_reader params: Array[AST::TypeParam]
+
+    # Type name
+    attr_reader type_name: TypeName
+
+    # Method name
+    attr_reader method_name: Symbol?
+
+    def initialize: (type_name: TypeName, method_name: Symbol?, params: Array[AST::TypeParam], location: Location[untyped, untyped]?) -> void
+  end
 end

data/sig/location.rbs

@@ -8,7 +8,7 @@ module RBS
   #
   # ```
   #
-  class Location[RequiredChildKeys, OptionalChildKeys]
+  class Location[in RequiredChildKeys, in OptionalChildKeys]
     # The buffer this location points on.
     attr_reader buffer (): Buffer
 
@@ -79,6 +79,8 @@ module RBS
           | (OptionalChildKeys) -> Location[bot, bot]?
           | (Symbol) -> Location[bot, bot]?
 
+    alias aref []
+
     def each_optional_key: () { (Symbol) -> void } -> void
                          | () -> Enumerator[Symbol, void]
 

data/sig/locator.rbs

@@ -7,7 +7,7 @@ module RBS
                    | MethodType
                    | AST::Declarations::t
                    | AST::Members::t
-                   | AST::Declarations::ModuleTypeParams::TypeParam
+                   | AST::TypeParam
                    | AST::Declarations::Class::Super
                    | AST::Declarations::Module::Self
 

data/sig/method_types.rbs

@@ -1,27 +1,48 @@
 module RBS
   class MethodType
-    attr_reader type_params: Array[Symbol]
+    # () -> void
+    # ^^^^^^^^^^     type
+    #
+    # [A] () { () -> A } -> A
+    # ^^^                      type_params
+    #     ^^^^^^^^^^^^^^^^^^^  type
+    #
+    type loc = Location[:type, :type_params]
+
+    attr_reader type_params: Array[AST::TypeParam]
     attr_reader type: Types::Function
     attr_reader block: Types::Block?
-    attr_reader location: Location[untyped, untyped]?
+    attr_reader location: loc?
 
-    def initialize: (type_params: Array[Symbol], type: Types::Function, block: Types::Block?, location: Location[untyped, untyped]?) -> void
+    def initialize: (type_params: Array[AST::TypeParam], type: Types::Function, block: Types::Block?, location: loc?) -> void
 
     def ==: (untyped other) -> bool
 
     include _ToJson
 
+    # Substitute type variables to some types.
+    # Takes care of type parameter bounds.
+    #
     def sub: (Substitution) -> MethodType
 
-    def update: (?type_params: Array[Symbol], ?type: Types::Function, ?block: Types::Block?, ?location: Location[untyped, untyped]?) -> MethodType
+    def update: (?type_params: Array[AST::TypeParam], ?type: Types::Function, ?block: Types::Block?, ?location: loc?) -> MethodType
 
     def free_variables: (?Set[Symbol] set) -> Set[Symbol]
 
+    # Apply the mapping included in the MethodType.
+    #
+    # Note that type bound in generics parameter is not handled by this method.
+    # You may want to use `#map_type_bound` explicitly, or `#sub` for simple substitution.
+    #
     def map_type: () { (Types::t) -> Types::t } -> MethodType
 
+    def map_type_bound: () { (AST::TypeParam::bound) -> AST::TypeParam::bound } -> MethodType
+
     def each_type: () { (Types::t) -> void } -> void
                  | () -> Enumerator[Types::t, void]
 
     def to_s: () -> String
+
+    def type_param_names: () -> Array[Symbol]
   end
 end

data/sig/type_param.rbs

@@ -0,0 +1,74 @@
+module RBS
+  module AST
+    class TypeParam
+      # Key
+      # ^^^ name
+      #
+      # unchecked out Elem < _ToJson
+      # ^^^^^^^^^                    unchecked
+      #           ^^^                variance
+      #               ^^^^           name
+      #                    ^^^^^^^^^ upper_bound
+      type loc = Location[:name, :variance | :unchecked | :upper_bound]
+
+      type variance = :invariant | :covariant | :contravariant
+
+      type bound = Types::ClassInstance | Types::ClassSingleton | Types::Interface
+
+      attr_reader name: Symbol
+      attr_reader variance: variance
+      attr_reader location: loc?
+
+      attr_reader upper_bound: bound?
+
+      def initialize: (name: Symbol, variance: variance, upper_bound: bound?, location: loc?) -> void
+
+      include _ToJson
+
+      def ==: (untyped) -> bool
+
+      def eql?: (untyped) -> bool
+
+      def hash: () -> Integer
+
+      @unchecked: bool
+
+      def unchecked!: (?boolish) -> self
+
+      def unchecked?: () -> bool
+
+      def map_type: () { (bound) -> bound } -> TypeParam
+
+      # Helper function to resolve _class instance types_ to _type variables_.
+      #
+      # We need this step because RBS language has an identical syntax for both unqualified class instance types and type variables.
+      # `String` may be an instance of `::String` class or type variable depending on the list of bound type variables.
+      #
+      # So, we need second pass to parse the following generics parameter declaration.
+      #
+      # ```rbs
+      # class Foo[X < _Each[Y], Y]
+      #                   # ^ We want this `Y` to be a type variable.
+      # end
+      # ```
+      #
+      def self.resolve_variables: (Array[TypeParam]) -> void
+
+      def self.subst_var: (Set[Symbol], Types::t) -> Types::t
+
+      # Rename type parameter name.
+      #
+      # The renaming cannot be done separately because a set of `TypeParam` decls may be mutual recursive.
+      #
+      # Example:
+      #
+      # * Renaming `A -> X, B -> Y`
+      # * Input `[A, B < _Pushable[A]]`
+      # * Result `[X, Y < _Pushable[X]]`
+      #
+      def self.rename: (Array[TypeParam], new_names: Array[Symbol]) -> Array[TypeParam]
+
+      def to_s: () -> String
+    end
+  end
+end

data/sig/types.rbs

@@ -55,6 +55,11 @@ module RBS
     module EmptyEachType
       def each_type: () { (t) -> void } -> void
                    | () -> Enumerator[t, void]
+
+      # `map_type` returns itself, because there is no sub type.
+      #
+      def map_type: () { (t) -> t } -> self
+                  | () -> Enumerator[t, self]
     end
 
     module NoTypeName
@@ -199,6 +204,9 @@ module RBS
       include _TypeBase
 
       attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Interface
+                  | () -> Enumerator[t, Interface]
     end
 
     # ClassInstance represents a type of an instance of a class.
@@ -224,6 +232,9 @@ module RBS
       attr_reader location: loc?
 
       include _TypeBase
+
+      def map_type: () { (t) -> t } -> ClassInstance
+                  | () -> Enumerator[t, ClassInstance]
     end
 
     class Alias
@@ -242,6 +253,9 @@ module RBS
 
       include _TypeBase
       include Application
+
+      def map_type: () { (t) -> t } -> Alias
+                  | () -> Enumerator[t, Alias]
     end
 
     class Tuple
@@ -254,6 +268,9 @@ module RBS
       include _TypeBase
 
       attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Tuple
+                  | () -> Enumerator[t, Tuple]
     end
 
     class Record
@@ -266,6 +283,9 @@ module RBS
       include _TypeBase
 
       attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Record
+                  | () -> Enumerator[t, Record]
     end
 
     class Optional
@@ -278,6 +298,9 @@ module RBS
       include _TypeBase
 
       attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Optional
+                  | () -> Enumerator[t, Optional]
     end
 
     class Union
@@ -395,7 +418,7 @@ module RBS
 
       def sub: (Substitution) -> Block
 
-      def map_type: () { (Types::t) -> Types::t } -> Block
+      def map_type: () { (t) -> t } -> Block
     end
 
     class Proc
@@ -409,6 +432,9 @@ module RBS
       include _TypeBase
 
       attr_reader location: loc?
+
+      def map_type: () { (t) -> t } -> Proc
+                  | () -> Enumerator[t, Proc]
     end
 
     class Literal

data/sig/validator.rbs

@@ -12,10 +12,39 @@ module RBS
 
     def initialize: (env: Environment, resolver: TypeNameResolver) -> void
 
-    def absolute_type: (Types::t, context: TypeNameResolver::context) { (Types::t) -> TypeName } -> Types::t
-
+    # Validates the presence of type names and type application arity match.
+    #
     def validate_type: (Types::t, context: TypeNameResolver::context) -> void
 
+    # Validates type alias definition:
+    #
+    # - There is no circular definition between aliases
+    # - The type alias is _regular_
+    # - The generics type parameter variance annotation is consistent with respect to their usage
+    # - There is no circular dependencies between the generics type parameter bounds
+    #
     def validate_type_alias: (entry: Environment::SingleEntry[TypeName, AST::Declarations::Alias]) -> void
+
+    # Validates the type parameters in generic methods.
+    #
+    def validate_method_definition: (AST::Members::MethodDefinition, type_name: TypeName) -> void
+
+    # Validates the type parameters if there is no circular dependencies between the bounds.
+    #
+    # ```rbs
+    # [X, Y]                      # OK
+    # [X, Y < _Foo[X]]            # OK
+    # [X < _Foo[Y], Y]            # OK
+    # [X < _Foo[Y], Y < _Foo[X]]  # Error
+    # ```
+    #
+    def validate_type_params: (Array[AST::TypeParam] params, type_name: TypeName, ?method_name: Symbol?, location: Location[untyped, untyped]?) -> 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
   end
 end

data/sig/variance_calculator.rbs

@@ -59,7 +59,7 @@ module RBS
 
       def compatible?: (Symbol, with_annotation: variance) -> bool
 
-      def incompatible?: (AST::Declarations::ModuleTypeParams) -> Set[Symbol]?
+      def incompatible?: (Array[AST::TypeParam]) -> Set[Symbol]?
     end
 
     attr_reader builder: DefinitionBuilder

data/sig/writer.rbs

@@ -27,7 +27,7 @@ module RBS
 
     def write_member: (AST::Declarations::Module::member) -> void
 
-    def name_and_params: (TypeName, AST::Declarations::ModuleTypeParams) -> String?
+    def name_and_params: (TypeName, Array[AST::TypeParam]) -> String?
 
     def name_and_args: (TypeName, Array[Types::t]) -> String?
 

data/stdlib/bigdecimal-math/0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: bigdecimal

data/stdlib/csv/0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: forwardable

data/stdlib/logger/0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: monitor

data/stdlib/net-http/0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: uri

data/stdlib/openssl/0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: socket

data/stdlib/prime/0/manifest.yaml

@@ -0,0 +1,2 @@
+dependencies:
+  - name: singleton

data/stdlib/resolv/0/manifest.yaml

@@ -0,0 +1,3 @@
+dependencies:
+  - name: socket
+  - name: timeout

data/stdlib/uri/0/common.rbs

@@ -154,7 +154,7 @@ module URI
   #
   # See URI.encode_www_form_component, URI.decode_www_form.
   #
-  def self.encode_www_form: (Enumerable[[ _ToS, _ToS ]] enum, ?encoding enc) -> String
+  def self.encode_www_form: (Enumerable[[ _ToS, _ToS ]] enum, ?encoding? enc) -> String
 
   # Encodes given `str` to URL-encoded form data.
   #
@@ -168,7 +168,7 @@ module URI
   #
   # See URI.decode_www_form_component, URI.encode_www_form.
   #
-  def self.encode_www_form_component: (String str, ?encoding enc) -> String
+  def self.encode_www_form_component: (_ToS str, ?encoding? enc) -> String
 
   # ## Synopsis
   #
@@ -268,7 +268,7 @@ module URI
   # It's recommended to first ::escape the provided `uri_str` if there are any
   # invalid URI characters.
   #
-  def self.parse: (String uri) -> URI::Generic
+  def self.parse: (_ToStr uri) -> (File | FTP | HTTP | HTTPS | LDAP | LDAPS | MailTo | WS | WSS | Generic)
 
   # ## Synopsis
   #
@@ -302,12 +302,17 @@ module URI
   #       p $&
   #     end
   #
-  def self.regexp: (?Array[String] schemes) -> Regexp
+  def self.regexp: (?Array[String]? schemes) -> Regexp
 
   # Returns a Hash of the defined schemes.
   #
   def self.scheme_list: () -> Hash[String, Class]
 
+  # Construct a URI instance, using the scheme to detect the appropriate class
+  # from +URI.scheme_list+.
+  #
+  def self.for: (String scheme, *untyped arguments, ?default: Class) -> (File | FTP | HTTP | HTTPS | LDAP | LDAPS | MailTo | WS | WSS | Generic)
+
   # ## Synopsis
   #
   #     URI::split(uri)
@@ -340,7 +345,7 @@ module URI
   #     URI.split("http://www.ruby-lang.org/")
   #     # => ["http", nil, "www.ruby-lang.org", nil, nil, "/", nil, nil, nil]
   #
-  def self.split: (String uri) -> [ String?, String?, String?, String?, String?, String?, String?, String?, String? ]
+  def self.split: (_ToStr uri) -> [ String?, String?, String?, String?, nil, String?, String?, String?, String? ]
 end
 
 URI::ABS_PATH: Regexp

data/stdlib/uri/0/ftp.rbs

@@ -0,0 +1,10 @@
+module URI
+  # FTP URI syntax is defined by RFC1738 section 3.2.
+  #
+  # This class will be redesigned because of difference of implementations;
+  # the structure of its path. draft-hoffman-ftp-uri-04 is a draft but it
+  # is a good summary about the de facto spec.
+  # http://tools.ietf.org/html/draft-hoffman-ftp-uri-04
+  class FTP < Generic
+  end
+end