rbs 1.7.0.beta.4 → 1.8.0

data/lib/rbs/variance_calculator.rb

@@ -54,6 +54,21 @@ module RBS
           false
         end
       end
+
+      def incompatible?(params)
+        # @type set: Hash[Symbol]
+        set = Set[]
+
+        params.each do |param|
+          unless compatible?(param.name, with_annotation: param.variance)
+            set << param.name
+          end
+        end
+
+        unless set.empty?
+          set
+        end
+      end
     end
 
     attr_reader :builder
@@ -69,19 +84,12 @@ module RBS
     def in_method_type(method_type:, variables:)
       result = Result.new(variables: variables)
 
-      method_type.type.each_param do |param|
-        type(param.type, result: result, context: :contravariant)
-      end
+      function(method_type.type, result: result, context: :covariant)
 
       if block = method_type.block
-        block.type.each_param do |param|
-          type(param.type, result: result, context: :covariant)
-        end
-        type(block.type.return_type, result: result, context: :contravariant)
+        function(block.type, result: result, context: :contravariant)
       end
 
-      type(method_type.type.return_type, result: result, context: :covariant)
-
       result
     end
 
@@ -97,6 +105,14 @@ module RBS
       end
     end
 
+    def in_type_alias(name:)
+      decl = env.alias_decls[name].decl or raise
+      variables = decl.type_params.each.map(&:name)
+      Result.new(variables: variables).tap do |result|
+        type(decl.type, result: result, context: :covariant)
+      end
+    end
+
     def type(type, result:, context:)
       case type
       when Types::Variable
@@ -110,7 +126,7 @@ module RBS
             result.invariant(type.name)
           end
         end
-      when Types::ClassInstance, Types::Interface
+      when Types::ClassInstance, Types::Interface, Types::Alias
         NoTypeFoundError.check!(type.name,
                                 env: env,
                                 location: type.location)
@@ -120,6 +136,8 @@ module RBS
                         env.class_decls[type.name].type_params
                       when Types::Interface
                         env.interface_decls[type.name].decl.type_params
+                      when Types::Alias
+                        env.alias_decls[type.name].decl.type_params
                       end
 
         type.args.each.with_index do |ty, i|
@@ -130,26 +148,36 @@ module RBS
           when :covariant
             type(ty, result: result, context: context)
           when :contravariant
-            # @type var con: variance
-            con = case context
-                  when :invariant
-                    :invariant
-                  when :covariant
-                    :contravariant
-                  when :contravariant
-                    :covariant
-                  else
-                    raise
-                  end
-            type(ty, result: result, context: con)
+            type(ty, result: result, context: negate(context))
           end
         end
-      when Types::Tuple, Types::Record, Types::Union, Types::Intersection
-        # Covariant types
+      when Types::Proc
+        function(type.type, result: result, context: context)
+      else
         type.each_type do |ty|
           type(ty, result: result, context: context)
         end
       end
     end
+
+    def function(type, result:, context:)
+      type.each_param do |param|
+        type(param.type, result: result, context: negate(context))
+      end
+      type(type.return_type, result: result, context: context)
+    end
+
+    def negate(variance)
+      case variance
+      when :invariant
+        :invariant
+      when :covariant
+        :contravariant
+      when :contravariant
+        :covariant
+      else
+        raise
+      end
+    end
   end
 end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.7.0.beta.4"
+  VERSION = "1.8.0"
 end

data/lib/rbs/writer.rb

@@ -119,7 +119,7 @@ module RBS
       when AST::Declarations::Alias
         write_comment decl.comment
         write_annotation decl.annotations
-        puts "type #{decl.name} = #{decl.type}"
+        puts "type #{name_and_params(decl.name, decl.type_params)} = #{decl.type}"
 
       when AST::Declarations::Interface
         write_comment decl.comment

data/lib/rbs.rb

@@ -32,6 +32,7 @@ require "rbs/constant"
 require "rbs/constant_table"
 require "rbs/ast/comment"
 require "rbs/writer"
+require "rbs/prototype/helpers"
 require "rbs/prototype/rbi"
 require "rbs/prototype/rb"
 require "rbs/prototype/runtime"
@@ -44,6 +45,7 @@ require "rbs/repository"
 require "rbs/ancestor_graph"
 require "rbs/locator"
 require "rbs/type_alias_dependency"
+require "rbs/type_alias_regularity"
 require "rbs/collection"
 
 require "rbs_extension"

data/schema/decls.json

@@ -12,6 +12,18 @@
         "name": {
           "type": "string"
         },
+        "type_params": {
+          "type": "object",
+          "properties": {
+            "params": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/moduleTypeParam"
+              }
+            }
+          },
+          "required": ["params"]
+        },
         "type": {
           "$ref": "types.json"
         },
@@ -28,7 +40,7 @@
           "$ref": "comment.json"
         }
       },
-      "required": ["declaration", "name", "type", "annotations", "location", "comment"]
+      "required": ["declaration", "name", "type_params", "type", "annotations", "location", "comment"]
     },
     "constant": {
       "title": "Constant declaration: `VERSION: String`, ...",

data/schema/types.json

@@ -106,7 +106,7 @@
       "required": ["class", "name", "args", "location"]
     },
     "alias": {
-      "title": "Type alias: `u`, `ty`, `json`, ...",
+      "title": "Type alias: `u`, `ty`, `json`, `list[Integer]`, ...",
       "type": "object",
       "properties": {
         "class": {
@@ -116,11 +116,17 @@
         "name": {
           "type": "string"
         },
+        "args": {
+          "type": "array",
+          "items": {
+            "$ref": "#"
+          }
+        },
         "location": {
           "$ref": "location.json"
         }
       },
-      "required": ["class", "name", "location"]
+      "required": ["class", "name", "args", "location"]
     },
     "tuple": {
       "title": "Tuple type: `[Foo, bar]`, ...",

data/sig/collection/collections.rbs

@@ -46,6 +46,8 @@ module RBS
 
         def _install: (dest: Pathname , config_entry: Config::gem_entry) -> void
 
+        def cp_r: (Pathname, Pathname) -> void
+
         def setup!: (revision: String) -> void
 
         def need_to_fetch?: (String revision ) -> bool

data/sig/declarations.rbs

@@ -217,19 +217,22 @@ module RBS
       end
 
       class Alias < Base
-        # type loc = Location
-        # ^^^^                keyword
-        #      ^^^            name
-        #          ^          eq
-        type loc = Location[:keyword | :name | :eq, bot]
+        # type loc[T] = Location[T, bot]
+        # ^^^^                            keyword
+        #      ^^^                        name
+        #         ^^^                     type_params
+        #             ^                      eq
+        #
+        type loc = Location[:keyword | :name | :eq, :type_params]
 
         attr_reader name: TypeName
+        attr_reader type_params: ModuleTypeParams
         attr_reader type: Types::t
         attr_reader annotations: Array[Annotation]
         attr_reader location: loc?
         attr_reader comment: Comment?
 
-        def initialize: (name: TypeName, type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type_params: ModuleTypeParams, type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson

data/sig/definition_builder.rbs

@@ -43,8 +43,37 @@ module RBS
 
     def define_methods: (Definition, interface_methods: Hash[Symbol, Definition::Method], methods: MethodBuilder::Methods, super_interface_method: bool) -> void
 
+    # Expand a type alias of given name without type arguments.
+    # Raises an error if the type alias requires arguments.
+    #
+    # Assume `type foo[T] = [T, T]`:
+    #
+    # ```
+    # expand_alias("::foo")   # => error
+    # ```
+    #
     def expand_alias: (TypeName) -> Types::t
 
+    # Expand a type alias of given name with arguments of `untyped`.
+    #
+    # Assume `type foo[T] = [T, T]`:
+    #
+    # ```
+    # expand_alias1("::foo")   # => [untyped, untyped]
+    # ```
+    #
+    def expand_alias1: (TypeName) -> Types::t
+
+    # Expand a type alias of given name with `args`.
+    #
+    # Assume `type foo[T] = [T, T]`:
+    #
+    # ```
+    # expand_alias2("::foo", ["::Integer"])   # => [::Integer, ::Integer]
+    # ```
+    #
+    def expand_alias2: (TypeName, Array[Types::t] args) -> Types::t
+
     def update: (env: Environment, ancestor_builder: AncestorBuilder, except: _Each[TypeName]) -> DefinitionBuilder
   end
 end

data/sig/environment_walker.rbs

@@ -1,4 +1,28 @@
 module RBS
+  # EnvironmentWalker provides topological sort of class/module definitions.
+  #
+  # If a method, attribute, or ancestor in a class definition have a reference to another class, it is dependency.
+  #
+  # ```rb
+  # walker = EnvironmentWalker.new(env: env)
+  #
+  # walker.each_strongly_connected_component do |scc|
+  #   # Yields an array of strongly connected components.
+  # end
+  # ```
+  #
+  # The `#only_ancestors!` method limits the dependency only to ancestors.
+  # Only super classes and included modules are dependencies with the option.
+  # This is useful to calculate the dependencies of class hierarchy.
+  #
+  # ```rb
+  # walker = EnvironmentWalker.new(env: env).only_ancestors!
+  #
+  # walker.each_strongly_connected_component do |scc|
+  #   # Yields an array of strongly connected components.
+  # end
+  # ```
+  #
   class EnvironmentWalker
     class InstanceNode
       attr_reader type_name: TypeName
@@ -32,6 +56,8 @@ module RBS
 
     def tsort_each_child: (node) { (node) -> void } -> void
 
+    private
+
     def each_type_name: (Types::t) { (TypeName) -> void } -> void
 
     def each_type_node: (Types::t) { (node) -> void } -> void

data/sig/errors.rbs

@@ -220,4 +220,14 @@ module RBS
 
     def name: () -> String
   end
+
+  class NonregularTypeAliasError < LoadingError
+    # Diagnostic reported from `TypeAliasRegularity`.
+    attr_reader diagnostic: TypeAliasRegularity::Diagnostic
+
+    # Location of the definition.
+    attr_reader location: Location[untyped, untyped]?
+
+    def initialize: (diagnostic: TypeAliasRegularity::Diagnostic, location: Location[untyped, untyped]?) -> void
+  end
 end

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