rbs 1.7.0.beta.5 → 1.8.1

data/sig/type_alias_regularity.rbs

@@ -0,0 +1,92 @@
+module RBS
+  # `TypeAliasRegularity` validates if a type alias is regular or not.
+  #
+  # Generic and recursive type alias cannot be polymorphic in their definitions.
+  #
+  # ```rbs
+  # type foo[T] = Integer
+  #             | foo[T]?     # Allowed. The type argument of `foo` doesn't change.
+  #
+  # type bar[T] = Integer
+  #             | foo[T]
+  #             | foo[Array[T]]  # Allowed. There are two type arguments `T` and `Array[T]` of `foo`, but it's not definition of `foo`.
+  #
+  # type baz[T] = Integer
+  #             | baz[Array[T]]  # Error. Recursive definition of `baz` has different type argument from the definition.
+  # ```
+  #
+  # The `#nonregular?` method can be used to test if given type name is regular or not.
+  #
+  # ```rb
+  # validator = RBS::TypeAliasRegularity.validate(env: env)
+  #
+  # validator.nonregular?(TypeName("::foo"))    # => nil
+  # validator.nonregular?(TypeName("::bar"))    # => nil
+  # validator.nonregular?(TypeName("::baz"))    # => TypeAliasRegularity::Diagnostic
+  # ```
+  #
+  # A special case is when the type argument is `untyped`.
+  #
+  # ```rbs
+  # type foo[T] = Integer | foo[untyped]    # This is allowed.
+  # ```
+  #
+  class TypeAliasRegularity
+    attr_reader env: Environment
+
+    attr_reader builder: DefinitionBuilder
+
+    attr_reader diagnostics: Hash[TypeName, Diagnostic]
+
+    # `Diagnostic` represents an non-regular type alias declaration error.
+    # It consists of the name of the alias type and a type on which the nonregularity is detected.
+    #
+    # ```rbs
+    # type t[T] = Integer | t[T?]
+    # ```
+    #
+    # 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.nonregular_type   # => t[T?]
+    # ```
+    #
+    class Diagnostic
+      attr_reader type_name: TypeName
+
+      attr_reader nonregular_type: Types::Alias
+
+      def initialize: (type_name: TypeName, nonregular_type: Types::Alias) -> void
+    end
+
+    # Returns new instance which already run `#validate`.
+    #
+    def self.validate: (env: Environment) -> TypeAliasRegularity
+
+    def initialize: (env: Environment) -> void
+
+    # Returns `Diagnostic` instance if the alias type is nonregular.
+    # Regurns `nil` if the alias type is regular.
+    #
+    def nonregular?: (TypeName) -> Diagnostic?
+
+    def validate: () -> void
+
+    private
+
+    def validate_alias_type: (Types::Alias, Set[TypeName], Hash[TypeName, Types::Alias]) -> void
+
+    # Returns alias type for given type name, if the alias is generic.
+    # Returns nil if the type alias is not generic.
+    #
+    def build_alias_type: (TypeName) -> Types::Alias?
+
+    def compatible_args?: (Array[Types::t], Array[Types::t]) -> boolish
+
+    def each_alias_type: (Types::t) { (Types::Alias) -> void } -> void
+
+    def each_mutual_alias_defs: () { (Set[TypeName]) -> void } -> void
+  end
+end

data/sig/types.rbs

@@ -227,18 +227,21 @@ module RBS
     end
 
     class Alias
-      attr_reader name: TypeName
+      # foo
+      # ^^^ => name
+      #
+      # foo[bar, baz]
+      # ^^^           => name
+      #    ^^^^^^^^^^ => args
+      #
+      type loc = Location[:name, :args]
 
-      type loc = Location[bot, bot]
+      attr_reader location: loc?
 
-      def initialize: (name: TypeName, location: loc?) -> void
+      def initialize: (name: TypeName, args: Array[t], location: loc?) -> void
 
       include _TypeBase
-      include NoFreeVariables
-      include NoSubst
-      include EmptyEachType
-
-      attr_reader location: loc?
+      include Application
     end
 
     class Tuple

data/sig/validator.rbs

@@ -1,8 +1,15 @@
 module RBS
   class Validator
     attr_reader env: Environment
+
     attr_reader resolver: TypeNameResolver
 
+    attr_reader definition_builder: DefinitionBuilder
+
+    attr_reader type_alias_dependency: TypeAliasDependency
+
+    attr_reader type_alias_regularity: TypeAliasRegularity
+
     def initialize: (env: Environment, resolver: TypeNameResolver) -> void
 
     def absolute_type: (Types::t, context: TypeNameResolver::context) { (Types::t) -> TypeName } -> Types::t

data/sig/variance_calculator.rbs

@@ -1,7 +1,47 @@
 module RBS
+  # Calculate the use variances of type variables in declaration.
+  #
+  # ```rb
+  # calculator = VarianceCalculator.new(builder: builder)
+  #
+  # # Calculates variances in a method type
+  # result = calculator.in_method_type(method_type: method_type, variables: variables)
+  #
+  # # Calculates variances in a inheritance/mixin/...
+  # result = calculator.in_inherit(name: name, args: args, variables: variables)
+  #
+  # # Calculates variances in a type alias
+  # result = calculator.in_type_alias(name: name, args: args, variables: variables)
+  # ```
+  #
+  # See `RBS::VarianceCaluculator::Result` for information recorded in the `Result` object.
+  #
   class VarianceCalculator
     type variance = :unused | :covariant | :contravariant | :invariant
 
+    # Result contains the set of type variables and it's variance in a occurrence.
+    #
+    # ```rb
+    # # Enumerates recorded type variables
+    # result.each do |name, variance|
+    #   # name is the name of a type variable
+    #   # variance is one of :unused | :covariant | :contravariant | :invariant
+    # end
+    # ```
+    #
+    # You can test with `compatible?` method if the type variable occurrences are compatible with specified (annotated) variance.
+    #
+    # ```rb
+    # # When T is declared as `out T`
+    # result.compatible?(:T, with_annotation: :covariant)
+    #
+    # # When T is declared as `in T`
+    # result.compatible?(:T, with_annotation: :contravariant)
+    #
+    # # When T is declared as `T`
+    # result.compatible?(:T, with_annotation: :invariant)
+    # ```
+    #
     class Result
       attr_reader result: Hash[Symbol, variance]
 
@@ -18,6 +58,8 @@ module RBS
       def include?: (Symbol) -> bool
 
       def compatible?: (Symbol, with_annotation: variance) -> bool
+
+      def incompatible?: (AST::Declarations::ModuleTypeParams) -> Set[Symbol]?
     end
 
     attr_reader builder: DefinitionBuilder
@@ -30,6 +72,14 @@ module RBS
 
     def in_inherit: (name: TypeName, args: Array[Types::t], variables: Array[Symbol]) -> Result
 
+    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 negate: (variance) -> variance
   end
 end

data/stdlib/bigdecimal/0/big_decimal.rbs

@@ -885,3 +885,47 @@ BigDecimal::SIGN_POSITIVE_ZERO: Integer
 # The version of bigdecimal library
 #
 BigDecimal::VERSION: String
+
+module Kernel
+  private
+
+  # Create a new BigDecimal object.
+  #
+  # initial
+  # :   The initial value, as an Integer, a Float, a Rational, a BigDecimal, or a
+  #     String.
+  #
+  #     If it is a String, spaces are ignored and unrecognized characters
+  #     terminate the value.
+  #
+  # digits
+  # :   The number of significant digits, as an Integer. If omitted or 0, the
+  #     number of significant digits is determined from the initial value.
+  #
+  #     The actual number of significant digits used in computation is usually
+  #     larger than the specified number.
+  #
+  # exception
+  # :   Whether an exception should be raised on invalid arguments. `true` by
+  #     default, if passed `false`, just returns `nil` for invalid.
+  #
+  #
+  # #### Exceptions
+  #
+  # TypeError
+  # :   If the `initial` type is neither Integer, Float, Rational, nor BigDecimal,
+  #     this exception is raised.
+  #
+  # TypeError
+  # :   If the `digits` is not an Integer, this exception is raised.
+  #
+  # ArgumentError
+  # :   If `initial` is a Float, and the `digits` is larger than Float::DIG + 1,
+  #     this exception is raised.
+  #
+  # ArgumentError
+  # :   If the `initial` is a Float or Rational, and the `digits` value is
+  #     omitted, this exception is raised.
+  #
+  def self?.BigDecimal: ((real | string | BigDecimal) initial, ?int digits, ?exception: bool) -> BigDecimal
+end

data/stdlib/csv/0/csv.rbs

@@ -360,6 +360,49 @@ class CSV < Object
   # output non-ASCII compatible data.
   #
   def self.generate: (?String str, **untyped options) { (CSV csv) -> void } -> String
+
+  # :call-seq:
+  #   csv.each -> enumerator
+  #   csv.each {|row| ...}
+  #
+  # Calls the block with each successive row.
+  # The data source must be opened for reading.
+  #
+  # Without headers:
+  #   string = "foo,0\nbar,1\nbaz,2\n"
+  #   csv = CSV.new(string)
+  #   csv.each do |row|
+  #     p row
+  #   end
+  # Output:
+  #   ["foo", "0"]
+  #   ["bar", "1"]
+  #   ["baz", "2"]
+  #
+  # With headers:
+  #   string = "Name,Value\nfoo,0\nbar,1\nbaz,2\n"
+  #   csv = CSV.new(string, headers: true)
+  #   csv.each do |row|
+  #     p row
+  #   end
+  # Output:
+  #   <CSV::Row "Name":"foo" "Value":"0">
+  #   <CSV::Row "Name":"bar" "Value":"1">
+  #   <CSV::Row "Name":"baz" "Value":"2">
+  #
+  # ---
+  #
+  # Raises an exception if the source is not opened for reading:
+  #   string = "foo,0\nbar,1\nbaz,2\n"
+  #   csv = CSV.new(string)
+  #   csv.close
+  #   # Raises IOError (not opened for reading)
+  #   csv.each do |row|
+  #     p row
+  #   end
+  def each: () -> Enumerator[untyped, Integer]
+          | () { (untyped) -> void } -> Integer
+
 end
 
 # The options used when no overrides are given by calling code. They are:
@@ -408,7 +451,7 @@ CSV::VERSION: String
 # processing is activated.
 #
 class CSV::Row < Object
-  include Enumerable[untyped]
+  include Enumerable[Array[String]]
   extend Forwardable
 
   # If a two-element Array is provided, it is assumed to be a header and field and
@@ -464,7 +507,8 @@ class CSV::Row < Object
   #
   # Support for Enumerable.
   #
-  def each: () { (*untyped) -> untyped } -> untyped
+  def each: () -> Enumerator[Array[String], self]
+          | () { (Array[String]) -> void } -> self
 
   alias each_pair each
 
@@ -717,7 +761,9 @@ class CSV::Table[out Elem] < Object
   #
   # If no block is given, an Enumerator is returned.
   #
-  def each: () { (*untyped) -> untyped } -> untyped
+  def each: () -> Enumerator[untyped, self]
+          | () { (untyped) -> void } -> self
+          | () { (*untyped) -> void } -> self
 
   def empty?: (*untyped args) { (*untyped) -> untyped } -> untyped
 

data/stdlib/date/0/date.rbs

@@ -446,7 +446,7 @@ class Date
   #     DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd
   #                               #=> #<DateTime: 2001-02-03T00:00:00+00:00 ...>
   #
-  def +: (Integer | Rational other) -> Date
+  def +: ((Numeric & _ToR) other) -> Date
 
   # Returns the difference between the two dates if the other is a date object.
   # If the other is a numeric value, returns a date object pointing `other` days
@@ -461,7 +461,7 @@ class Date
   #     DateTime.new(2001,2,3) - DateTime.new(2001,2,2,12)
   #                              #=> (1/2)
   #
-  def -: (Integer | Rational other) -> Date
+  def -: ((Numeric & _ToR) other) -> Date
        | (Date other) -> Rational
 
   # Returns a date object pointing `n` months before self. The argument `n` should

data/stdlib/set/0/set.rbs

@@ -122,7 +122,7 @@ class Set[A]
   #
   # See also Enumerable#include?
   #
-  def include?: (untyped) -> bool
+  def include?: (A) -> bool
 
   alias member? include?
 
@@ -168,12 +168,12 @@ class Set[A]
   # Deletes the given object from the set and returns self.  Use `subtract` to
   # delete many items at once.
   #
-  def delete: (untyped) -> self
+  def delete: (A) -> self
 
   # Deletes the given object from the set and returns self.  If the object is not
   # in the set, returns nil.
   #
-  def delete?: (untyped) -> self?
+  def delete?: (A) -> self?
 
   # Deletes every element of the set for which block evaluates to true, and
   # returns self. Returns an enumerator if no block is given.

data/steep/Gemfile.lock

@@ -9,37 +9,37 @@ GEM
       zeitwerk (~> 2.3)
     ast (2.4.2)
     concurrent-ruby (1.1.9)
-    ffi (1.15.3)
-    i18n (1.8.10)
+    ffi (1.15.4)
+    i18n (1.8.11)
       concurrent-ruby (~> 1.0)
     language_server-protocol (3.16.0.3)
     listen (3.7.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     minitest (5.14.4)
-    parallel (1.20.1)
-    parser (3.0.2.0)
+    parallel (1.21.0)
+    parser (3.0.3.1)
       ast (~> 2.4.1)
     rainbow (3.0.0)
     rb-fsevent (0.11.0)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (1.5.1)
-    steep (0.46.0)
+    rbs (1.7.1)
+    steep (0.47.0)
       activesupport (>= 5.1)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)
       parallel (>= 1.0.0)
       parser (>= 3.0)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (>= 1.2.0)
+      rbs (~> 1.7.0)
       terminal-table (>= 2, < 4)
-    terminal-table (3.0.1)
+    terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (2.0.0)
-    zeitwerk (2.4.2)
+    unicode-display_width (2.1.0)
+    zeitwerk (2.5.1)
 
 PLATFORMS
   ruby

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs
 version: !ruby/object:Gem::Version
-  version: 1.7.0.beta.5
+  version: 1.8.1
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-07 00:00:00.000000000 Z
+date: 2021-12-13 00:00:00.000000000 Z
 dependencies: []
 description: RBS is the language for type signatures for Ruby and standard library
   definitions.
@@ -44,6 +44,7 @@ files:
 - core/encoding.rbs
 - core/enumerable.rbs
 - core/enumerator.rbs
+- core/env.rbs
 - core/errno.rbs
 - core/errors.rbs
 - core/exception.rbs
@@ -152,7 +153,6 @@ files:
 - lib/rbs/locator.rb
 - lib/rbs/method_type.rb
 - lib/rbs/namespace.rb
-- lib/rbs/parser.y
 - lib/rbs/parser_aux.rb
 - lib/rbs/parser_compat/lexer_error.rb
 - lib/rbs/parser_compat/located_value.rb
@@ -174,6 +174,7 @@ files:
 - lib/rbs/test/tester.rb
 - lib/rbs/test/type_check.rb
 - lib/rbs/type_alias_dependency.rb
+- lib/rbs/type_alias_regularity.rb
 - lib/rbs/type_name.rb
 - lib/rbs/type_name_resolver.rb
 - lib/rbs/types.rb
@@ -182,7 +183,6 @@ files:
 - lib/rbs/vendorer.rb
 - lib/rbs/version.rb
 - lib/rbs/writer.rb
-- lib/ruby/signature.rb
 - rbs.gemspec
 - schema/annotation.json
 - schema/comment.json
@@ -226,6 +226,7 @@ files:
 - sig/repository.rbs
 - sig/substitution.rbs
 - sig/type_alias_dependency.rbs
+- sig/type_alias_regularity.rbs
 - sig/type_name_resolver.rbs
 - sig/typename.rbs
 - sig/types.rbs
@@ -341,9 +342,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.2.22
 signing_key: