rbs 1.7.0 → 2.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e6fc59a79d872f87e6e58e32c2c92d70ec59c0fad26d5a094a7a21d4b108e6c
-  data.tar.gz: 950a60b79c02ebdd4d6dd39ff2fc0c7fef9a69843111bc7ed6640c732afd0d98
+  metadata.gz: df2f2f119ca85f630c640b201ebf9ce72322db96223de2fb1d4ba77df68aee59
+  data.tar.gz: 82943e12963a10f2a4dbd30096fe40fb90ee4b23d6239bd515526a39d2af3b97
 SHA512:
-  metadata.gz: a59a9dbf9bbd5c85e3462fb5d0e1edf9a879b87db78cf409a5af921a40ce375f72a7475fe0c7eda0350ed604e876197262e0195a4812177410ff1b31edf41252
-  data.tar.gz: b739f7415fefb9ed0cb5db63de98ab648dcd320ac98abd9211bb85448f3fbb14855fcb61715a6c6f4cf520308b2fa0a73c93217bd4e0dd8818d759446e3a6264
+  metadata.gz: 9dbd99091da5e5d116a5bb428383c3e63e8b8ee4207ea859e177577b33a1d1dc3d312bb31f03fcda61d90993b4a9ab1ccab69855e7ecb8e986f9696a638c618d
+  data.tar.gz: dc05caaa25da531bbe353eb0294fbe016a90039eef12a040f2c5b07f409683c9fbc6c3406beba8c8d76f25f5b0ed7bbc3501967cc84fcc000a2e49fda85e84a3

data/CHANGELOG.md

@@ -2,12 +2,104 @@
 
 ## master
 
+## 2.0.0 (pre1)
+
+### Bounded Generics
+
+RBS 2.0 ships with _bounded generics_, which improves the expressiveness of the language by adding new syntax to define the constraint on type parameters.
+
+```rbs
+class PrettyPrint[T < _Output]
+  interface _Output
+    def <<: (String) -> void
+  end
+
+  attr_reader output: T
+
+  def initialize: (T output) -> void
+end
+```
+
+This is the motivating example I found in the [prettyprint library](https://github.com/ruby/prettyprint).
+The `#initialize` receives a object of type `T` and it must have `#<<` method.
+This is defined with `< _Output` syntax in the example.
+It means _`T` has to be compatible with `_Output` interface._
+`PrettyPrint[String]` is okay, but `PrettyPrint[Integer]` is a type error.
+
+See [the PR for details](https://github.com/ruby/rbs/pull/844).
+
+`manifest.yaml` allows declaring the dependencies from your gems to standard libraries explicitly.
+
+This version contains a bug fix, which potentially breaks the compatibility with older versions.
+The super class names in class definitions are now resolved in _outer_ context.
+It was an incompatibility with Ruby and [this PR](https://github.com/ruby/rbs/pull/856) fixed the problem.
+
+### Signature updates
+
+* uri ([\#846](https://github.com/ruby/rbs/pull/846), [\#852](https://github.com/ruby/rbs/pull/852), [\#851](https://github.com/ruby/rbs/pull/851), [\#850](https://github.com/ruby/rbs/pull/850))
+
+### Language updates
+
+* Bounded generics ([\#844](https://github.com/ruby/rbs/pull/844))
+* Resolve super type names in outer context ([\#856](https://github.com/ruby/rbs/pull/856))
+
+### Library changes
+
+* Add `manifest.yaml` for collection to specify stdlib dependencies ([\#808](https://github.com/ruby/rbs/pull/808))
+* Remove experimental warning of `rbs collection` ([\#855](https://github.com/ruby/rbs/pull/855))
+* Add the utility `#map_type` methods ([\#841](https://github.com/ruby/rbs/pull/841))
+
+## 1.8.1 (2021-12-13)
+
+### Library changes
+
+* Validate `extend` arguments ([\#840](https://github.com/ruby/rbs/pull/840))
+* Allow a relative path as git remote in collection ([\#839](https://github.com/ruby/rbs/pull/839))
+
+## 1.8.0 (2021-12-02)
+
+RBS 1.8.0 ships with a language feature enhancement, _generic type alias_.
+You can define a type alias with type parameters now.
+
+```rbs
+type list[T] = [T, list[T]] | nil  # Defines a list of type T
+
+type int_list = list[Integer]      # List of Integer
+type string_list = list[String]    # List of String
+```
+
+You can find the detail in the [PR](https://github.com/ruby/rbs/pull/823).
+
+### Signature updates
+
+* `Date#+`, `Date#-` ([\#830](https://github.com/ruby/rbs/pull/830))
+* `#include?`, `#member?`, `#delete`, `#count` ([\#835](https://github.com/ruby/rbs/pull/835))
+
+### Language updates
+
+* Generic type alias ([\#823](https://github.com/ruby/rbs/pull/823))
+
+## 1.7.1 (2021-11-18)
+
+### Signature updates
+
+* `Thread#value` ([\#824](https://github.com/ruby/rbs/pull/824/files))
+
+### Library changes
+
+* Unquote parameter name ([\#827](https://github.com/ruby/rbs/pull/827))
+* Remove `ruby/signature.rb` ([\#825](https://github.com/ruby/rbs/pull/825))
+
+### Miscellaneous
+
+* Use `untyped` as an expectation of return value of `IO#ready?` in test ([\#828](https://github.com/ruby/rbs/pull/828/files))
+
 ## 1.7.0 (2021-11-11)
 
 This version replaces `RBS::Parser` implementation from pure Ruby code based on [Racc](https://github.com/ruby/racc) to C extension.
 It improves the RBS file parsing performance up to 5 times faster. :rocket:
 
-* There are some incompatibilties to drop obsolete syntax rules: `super` keyword and `any` type are no longer supported.
+* There are some incompatibilities to drop obsolete syntax rules: `super` keyword and `any` type are no longer supported.
 * [re2c](https://github.com/skvadrik/re2c) is used to generate lexical generator.
 
 When you want to change the parser/lexer, change the files under `ext/rbs_extension` directory and run `rake compile` to compile the extension.
@@ -120,7 +212,7 @@ This release includes feature enhancements including recursive `type` definition
 
 ### Library changes
 
-* Add Recursiive type alias defnition validation ([\#719](https://github.com/ruby/rbs/pull/719))
+* Add Recursive type alias definition validation ([\#719](https://github.com/ruby/rbs/pull/719))
 * Generate included modules with complete name ([\#731](https://github.com/ruby/rbs/pull/731))
 * Fix `rbs-prototype-rb` error when multi assign with const ([\#740](https://github.com/ruby/rbs/pull/740))
 
@@ -148,7 +240,7 @@ This release is to fix a bug introduced by parser update in 1.3.0.
 
 ### Summary
 
-RBS 1.3.0 includes bug fixees of the parser and class/module definition validations.
+RBS 1.3.0 includes bug fixes of the parser and class/module definition validations.
 
 ### Signature updates
 

data/core/array.rbs

@@ -699,7 +699,7 @@ class Array[unchecked out Elem] < Object
   #     ary.count {|x| x%2 == 0}   #=> 3
   #
   def count: () -> ::Integer
-           | (untyped obj) -> ::Integer
+           | (Elem obj) -> ::Integer
            | () { (Elem) -> boolish } -> ::Integer
 
   # Calls the given block for each element `n` times or forever if `nil` is given.
@@ -733,7 +733,7 @@ class Array[unchecked out Elem] < Object
   #     a.delete("z")                   #=> nil
   #     a.delete("z") {"not found"}     #=> "not found"
   #
-  def delete: (untyped obj) -> Elem?
+  def delete: (Elem obj) -> Elem?
             | [S, T] (S obj) { (S) -> T } -> (Elem | T)
 
   # Deletes the element at the specified `index`, returning that element, or `nil`
@@ -1029,7 +1029,7 @@ class Array[unchecked out Elem] < Object
   #     a.include?("b")   #=> true
   #     a.include?("z")   #=> false
   #
-  def include?: (untyped object) -> bool
+  def include?: (Elem object) -> bool
 
   # Returns the *index* of the first object in `ary` such that the object is `==`
   # to `obj`.

data/core/builtin.rbs

@@ -6,6 +6,10 @@ interface _ToInt
   def to_int: -> Integer
 end
 
+interface _ToR
+  def to_r: () -> Rational
+end
+
 interface _ToS
   def to_s: -> String
 end

data/core/enumerable.rbs

@@ -63,7 +63,7 @@ module Enumerable[unchecked out Elem]: _Each[Elem]
   # ary.count{ |x| x%2==0 } #=> 3
   # ```
   def count: () -> Integer
-           | (?untyped) -> Integer
+           | (Elem) -> Integer
            | () { (Elem) -> boolish } -> Integer
 
   def cycle: (?Integer n) { (Elem arg0) -> untyped } -> NilClass
@@ -130,7 +130,7 @@ module Enumerable[unchecked out Elem]: _Each[Elem]
   def group_by: [U] () { (Elem arg0) -> U } -> ::Hash[U, ::Array[Elem]]
               | () -> ::Enumerator[Elem, ::Array[Elem]]
 
-  def `include?`: (untyped arg0) -> bool
+  def `include?`: (Elem arg0) -> bool
 
   def inject: (untyped init, Symbol method) -> untyped
             | (Symbol method) -> untyped
@@ -341,7 +341,7 @@ module Enumerable[unchecked out Elem]: _Each[Elem]
   def map: [U] () { (Elem arg0) -> U } -> ::Array[U]
          | () -> ::Enumerator[Elem, ::Array[untyped]]
 
-  def member?: (untyped arg0) -> bool
+  def member?: (Elem arg0) -> bool
 
   alias reduce inject
 

data/core/thread.rbs

@@ -554,7 +554,7 @@ class Thread < Object
   # b = Thread.new { raise 'something went wrong' }
   # b.value   #=> RuntimeError: something went wrong
   # ```
-  def value: () -> Object
+  def value: () -> untyped
 
   # Marks a given thread as eligible for scheduling, however it may still
   # remain blocked on I/O.

data/docs/collection.md

@@ -7,7 +7,6 @@
 * `git(1)`
 * `Gemfile.lock`
 
-
 ## Usage
 
 ### Setup
@@ -65,9 +64,13 @@ Finally the third party RBSs are available! `rbs` commands, such as `rbs validat
 
 ## Configuration
 
+### `rbs_collection.yaml`
+
 Configure `rbs collection` with editing `rbs_collection.yaml`.
 
 ```yaml
+# rbs_collection.yaml
+
 # Download sources.
 # You can add own collection git repository.
 sources:
@@ -92,6 +95,25 @@ gems:
     ignore: true
 ```
 
+### `manifest.yaml`
+
+If you are a gem maintainer, you can write `manifest.yaml`.
+You need to put the file if the gem has implicit dependencies, which don't appear in `Gemfile.lock`. You have to write standard libraries' dependencies in most cases.
+For example:
+
+```yaml
+# manifest.yaml
+
+dependencies:
+  # If your gem depends on pathname but the gemspec doesn't include pathname,
+  # you need to write the following.
+  - name: pathname
+```
+
+If the gem's RBS is managed with [ruby/gem_rbs_collection](https://github.com/ruby/gem_rbs_collection), put it as `gems/GEM_NAME/VERSION/manifest.yaml`.  For example, `gems/activesupport/6.0/manifest.yaml`.
+If the gem's RBS is included in the gem package, put it as `sig/manifest.yaml`.
+
+
 ## Files / Directories
 
 * `rbs_collection.yaml`

data/docs/syntax.md

@@ -5,14 +5,14 @@
 ```markdown
 _type_ ::= _class-name_ _type-arguments_                (Class instance type)
          | _interface-name_ _type-arguments_            (Interface type)
+         | _alias-name_ _type-arguments_                (Alias type)
          | `singleton(` _class-name_ `)`                (Class singleton type)
-         | _alias-name_                                 (Alias type)
          | _literal_                                    (Literal type)
          | _type_ `|` _type_                            (Union type)
          | _type_ `&` _type_                            (Intersection type)
          | _type_ `?`                                   (Optional type)
-         | `{` _record-name_ `:` _type_ `,` etc. `}`     (Record type)
-         | `[]` | `[` _type_ `,` etc. `]`                (Tuples)
+         | `{` _record-name_ `:` _type_ `,` etc. `}`    (Record type)
+         | `[]` | `[` _type_ `,` etc. `]`               (Tuples)
          | _type-variable_                              (Type variables)
          | `^(` _parameters_ `) ->` _type_              (Proc type)
          | `self`
@@ -35,8 +35,8 @@ _namespace_ ::=                                         (Empty namespace)
               | `::`                                    (Root)
               | _namespace_ /[A-Z]\w*/ `::`             (Namespace)
 
-_type-arguments_ ::=                                    (No application)
-                   | `[` _type_ `,` etc. `]`             (Type application)
+_type-arguments_ ::=                                    (No type arguments)
+                   | `[` _type_ `,` etc. `]`            (Type arguments)
 
 _literal_ ::= _string-literal_
             | _symbol-literal_
@@ -64,25 +64,25 @@ _ToS                          # _ToS interface
 ::MyApp::_Each[String]        # Interface name with namespace and type application
 ```
 
-### Class singleton type
-
-Class singleton type denotes _the type of a singleton object of a class_.
-
-```
-singleton(String)
-singleton(::Hash)            # Class singleton type cannot be parametrized.
-```
-
 ### Alias type
 
 Alias type denotes an alias declared with _alias declaration_.
 
 The name of type aliases starts with lowercase `[a-z]`.
 
-
 ```
 name
 ::JSON::t                    # Alias name with namespace
+list[Integer]                # Type alias can be generic
+```
+
+### Class singleton type
+
+Class singleton type denotes _the type of a singleton object of a class_.
+
+```
+singleton(String)
+singleton(::Hash)            # Class singleton type cannot be parametrized.
 ```
 
 ### Literal type
@@ -155,7 +155,7 @@ Elem
 ```
 
 Type variables cannot be distinguished from _class instance types_.
-They are scoped in _class/module/interface declaration_ or _generic method types_.
+They are scoped in _class/module/interface/alias declaration_ or _generic method types_.
 
 ```
 class Ref[T]              # Object is scoped in the class declaration.
@@ -288,12 +288,12 @@ _method-member_ ::= `def` _method-name_ `:` _method-types_            # Instance
                   | `def self.` _method-name_ `:` _method-types_      # Singleton method
                   | `def self?.` _method-name_ `:` _method-types_     # Singleton and instance method
 
-_method-types_ ::=                                                       # Empty
-                 | _type-parameters_ _method-type_ `|` _method-types_    # Overloading types
-                 | `...`                                                 # Overloading for duplicate definitions
+_method-types_ ::= _method-type-parameters_ _method-type_                       # Single method type
+                 | _method-type-parameters_ _method-type_ `|` _method-types_    # Overloading types
+                 | `...`                                                        # Overloading for duplicate definitions
 
-_type-parameters_ ::=                                                 # Empty
-                    | `[` _type-variable_ `,` etc. `]`
+_method-type-parameters_ ::=                                                    # Empty
+                           | `[` _type-variable_ `,` ... `]`
 
 _attribute-member_ ::= _attribute-type_ _method-name_ `:` _type_                     # Attribute
                      | _attribute-type_ _method-name_ `(` _ivar-name_ `) :` _type_   # Attribute with variable name specification
@@ -414,7 +414,6 @@ These work only as _statements_, not per-method specifier.
 _decl_ ::= _class-decl_                         # Class declaration
          | _module-decl_                        # Module declaration
          | _interface-decl_                     # Interface declaration
-         | _extension-decl_                     # Extension declaration
          | _type-alias-decl_                    # Type alias declaration
          | _const-decl_                         # Constant declaration
          | _global-decl_                        # Global declaration
@@ -434,9 +433,7 @@ _interface-members_ ::= _method-member_              # Method
                       | _include-member_             # Mixin (include)
                       | _alias-member_               # Alias
 
-_extension-decl_ ::= `extension` _class-name_ _type-parameters_ `(` _extension-name_ `)` _members_ `end`
-
-_type-alias-decl_ ::= `type` _alias-name_ `=` _type_
+_type-alias-decl_ ::= `type` _alias-name_ _module-type-parameters_ `=` _type_
 
 _const-decl_ ::= _const-name_ `:` _type_
 
@@ -446,48 +443,13 @@ _const-name_ ::= _namespace_ /[A-Z]\w*/
 _global-name_ ::= /$[a-zA-Z]\w+/ | ...
 
 _module-type-parameters_ ::=                                                  # Empty
-                           | `[` _module-type-parameter_ `,` etc. `]`
-
-_module-type-parameter_ ::= _check_ _variance_ _type-variable_
-_variance_ ::= `out` | `in`
-_check_ ::= # Empty
-          | `unchecked`
+                           | `[` _module-type-parameter_ `,` ... `]`
 ```
 
 ### Class declaration
 
 Class declaration can have type parameters and superclass. When you omit superclass, `::Object` is assumed.
 
-```
-class Ref[A] < Object
-  attr_reader value: A
-  def initialize: (value: A) -> void
-end
-```
-
-For classes with type parameters, you may specify if they are "invariant" (default), "covariant" (`out`) or "contravariant" (`in`). See [this definition of covariance and contravariance](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)).
-
-For example, an `Array` of `String` can almost be considered to be an `Array` of `Object`, but not the reverse, so we can think of:
-
-```
-class Array[out T]
-  # etc.
-end
-```
-
-There's a limitation with this is for mutable objects (like arrays): a mutation could invalidate this.
-If an array of String is passed to a method as an array of Objects, and that method adds an Integer to the array, the promise is broken.
-
-In those cases, one must use the `unchecked` keyword:
-
-```
-class Array[unchecked out T]
-  # etc.
-end
-```
-
-This is how `Array` is actually defined in RBS.
-
 ### Module declaration
 
 Module declaration takes optional _self type_ parameter, which defines a constraint about a class when the module is mixed.
@@ -536,6 +498,12 @@ type subject = Attendee | Speaker
 type JSON::t = Integer | TrueClass | FalseClass | String | Hash[Symbol, t] | Array[t]
 ```
 
+Type alias can be generic like class, module, and interface.
+
+```
+type list[out T] = [T, list[T]] | nil
+```
+
 ### Constant type declaration
 
 You can declare a constant.
@@ -552,6 +520,94 @@ You can declare a global variable.
 $LOAD_PATH: Array[String]
 ```
 
+### Generics
+
+```md
+_module-type-parameter_ ::= _generics-unchecked_ _generics-variance_ _type-variable_ _generics-bound_
+
+_method-type-param_ ::= _type-variable_ _generics-bound_
+
+_generics-bound_ ::=                       (No type bound)
+                   | `<` _bound-type_      (The generics parameter is bounded)
+
+_bound-type_ ::= _class-name_ _type-arguments_       (Class instance type)
+              | _interface-name_ _type-arguments_    (Interface type)
+              | `singleton(` _class-name_ `)`        (Class singleton type)
+
+_generics-variance_ ::=               (Invariant)
+                      | `out`         (Covariant)
+                      | `in`          (Contravariant)
+
+_generics-unchecked_ ::=              (Empty)
+                       | `unchecked`  (Skips variance annotation validation)
+```
+
+RBS allows class/module/interface/type alias definitions and methods to be generic.
+
+```rbs
+# Simple generic class definition
+class Stack[T]
+  def push: (T) -> void
+
+  def pop: () -> T
+end
+```
+
+For classes with type parameters, you may specify if they are "invariant" (default), "covariant" (`out`) or "contravariant" (`in`). See [this definition of covariance and contravariance](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)).
+
+For example, an `Array` of `String` can almost be considered to be an `Array` of `Object`, but not the reverse, so we can think of:
+
+```
+# The `T` type parameter is covariant.
+class Array[out T]
+  # etc.
+end
+```
+
+There's a limitation with this is for mutable objects (like arrays): a mutation could invalidate this.
+If an array of `String` is passed to a method as an array of `Objects`, and that method adds an Integer to the array, the promise is broken.
+
+In those cases, one must use the `unchecked` keyword:
+
+```rbs
+# Skips the validation of variance of the type parameter `T`.
+# The type safety prohibits `out` type parameters to appear at _negative_ position (== method parameter), but we want `Array` to have it.
+class Array[unchecked out T]
+  def include?: (T) -> bool
+end
+```
+
+This is how `Array` is actually defined in RBS.
+
+Note that RBS doesn't allow specifying variance related annotations to generic method types.
+
+```rbs
+class Foo
+  def bar: [out T] () -> T    # Syntax error
+end
+```
+
+You can also specify the _upper bound_ of the type parameter.
+
+```rbs
+class PrettyPrint[T < _Output]
+  interface _Output
+    def <<: (String) -> void
+  end
+
+  attr_reader output: T
+end
+```
+
+If a type parameter has an upper bound, the type parameter must be instantiated with types that is a subclass of the upper bound.
+
+```rbs
+type str_printer = PrettyPrint[String]    # OK
+type int_printer = PrettyPrint[Integer]      # Type error
+```
+
+The upper bound must be one of a class instance type, interface type, or class singleton type.
+
 ### Comments
 
 You can write single line comments. Comments must be on their own line. Comments can lead with whitespace.

data/ext/rbs_extension/constants.c

@@ -6,12 +6,10 @@ VALUE RBS;
 VALUE RBS_AST;
 VALUE RBS_AST_Comment;
 VALUE RBS_AST_Annotation;
+VALUE RBS_AST_TypeParam;
 
 VALUE RBS_AST_Declarations;
 
-VALUE RBS_AST_Declarations_ModuleTypeParams;
-VALUE RBS_AST_Declarations_ModuleTypeParams_TypeParam;
-
 VALUE RBS_AST_Declarations_Alias;
 VALUE RBS_AST_Declarations_Constant;
 VALUE RBS_AST_Declarations_Global;
@@ -77,12 +75,10 @@ void rbs__init_constants() {
   RBS_AST = rb_const_get(RBS, rb_intern("AST"));
   RBS_AST_Comment = rb_const_get(RBS_AST, rb_intern("Comment"));
   RBS_AST_Annotation = rb_const_get(RBS_AST, rb_intern("Annotation"));
+  RBS_AST_TypeParam = rb_const_get(RBS_AST, rb_intern("TypeParam"));
 
   RBS_AST_Declarations = rb_const_get(RBS_AST, rb_intern("Declarations"));
 
-  RBS_AST_Declarations_ModuleTypeParams = rb_const_get(RBS_AST_Declarations, rb_intern("ModuleTypeParams"));
-  RBS_AST_Declarations_ModuleTypeParams_TypeParam = rb_const_get(RBS_AST_Declarations_ModuleTypeParams, rb_intern("TypeParam"));
-
   RBS_AST_Declarations_Alias = rb_const_get(RBS_AST_Declarations, rb_intern("Alias"));
   RBS_AST_Declarations_Constant = rb_const_get(RBS_AST_Declarations, rb_intern("Constant"));
   RBS_AST_Declarations_Global = rb_const_get(RBS_AST_Declarations, rb_intern("Global"));

data/ext/rbs_extension/constants.h

@@ -6,6 +6,7 @@ extern VALUE RBS;
 extern VALUE RBS_AST;
 extern VALUE RBS_AST_Annotation;
 extern VALUE RBS_AST_Comment;
+extern VALUE RBS_AST_TypeParam;
 
 extern VALUE RBS_AST_Declarations;
 extern VALUE RBS_AST_Declarations_Alias;
@@ -16,8 +17,6 @@ extern VALUE RBS_AST_Declarations_Global;
 extern VALUE RBS_AST_Declarations_Interface;
 extern VALUE RBS_AST_Declarations_Module_Self;
 extern VALUE RBS_AST_Declarations_Module;
-extern VALUE RBS_AST_Declarations_ModuleTypeParams_TypeParam;
-extern VALUE RBS_AST_Declarations_ModuleTypeParams;
 
 extern VALUE RBS_AST_Members;
 extern VALUE RBS_AST_Members_Alias;