rbs 1.8.0 → 2.0.0

data/lib/rbs/method_type.rb

@@ -29,11 +29,18 @@ module RBS
     end
 
     def sub(s)
-      s.without(*type_params).yield_self do |sub|
-        map_type do |ty|
-          ty.sub(sub)
-        end
-      end
+      sub = s.without(*type_param_names)
+
+      self.class.new(
+        type_params: type_params.map do |param|
+          param.map_type do |bound|
+            bound.map_type {|ty| ty.sub(sub) }
+          end
+        end,
+        type: type.sub(sub),
+        block: block&.sub(sub),
+        location: location
+      )
     end
 
     def update(type_params: self.type_params, type: self.type, block: self.block, location: self.location)
@@ -48,7 +55,7 @@ module RBS
     def free_variables(set = Set.new)
       type.free_variables(set)
       block&.type&.free_variables(set)
-      set.subtract(type_params)
+      set.subtract(type_param_names)
     end
 
     def map_type(&block)
@@ -62,6 +69,18 @@ module RBS
       )
     end
 
+    def map_type_bound(&block)
+      if type_params.empty?
+        self
+      else
+        self.update(
+          type_params: type_params.map {|param|
+            param.map_type(&block)
+          }
+        )
+      end
+    end
+
     def each_type(&block)
       if block
         type.each_type(&block)
@@ -89,5 +108,9 @@ module RBS
         "[#{type_params.join(", ")}] #{s}"
       end
     end
+
+    def type_param_names
+      type_params.map(&:name)
+    end
   end
 end

data/lib/rbs/prototype/rb.rb

@@ -49,7 +49,7 @@ module RBS
             annotations: [],
             comment: nil,
             location: nil,
-            type_params: AST::Declarations::ModuleTypeParams.empty
+            type_params: []
           )
           decls << top
         end
@@ -88,7 +88,7 @@ module RBS
           kls = AST::Declarations::Class.new(
             name: const_to_name(class_name),
             super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
-            type_params: AST::Declarations::ModuleTypeParams.empty,
+            type_params: [],
             members: [],
             annotations: [],
             location: nil,
@@ -108,7 +108,7 @@ module RBS
 
           mod = AST::Declarations::Module.new(
             name: const_to_name(module_name),
-            type_params: AST::Declarations::ModuleTypeParams.empty,
+            type_params: [],
             self_types: [],
             members: [],
             annotations: [],

data/lib/rbs/prototype/rbi.rb

@@ -48,7 +48,7 @@ module RBS
         modules.push AST::Declarations::Class.new(
           name: nested_name(name),
           super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
-          type_params: AST::Declarations::ModuleTypeParams.empty,
+          type_params: [],
           members: [],
           annotations: [],
           location: nil,
@@ -65,7 +65,7 @@ module RBS
       def push_module(name, comment:)
         modules.push AST::Declarations::Module.new(
           name: nested_name(name),
-          type_params: AST::Declarations::ModuleTypeParams.empty,
+          type_params: [],
           members: [],
           annotations: [],
           location: nil,
@@ -212,10 +212,12 @@ module RBS
                            end
               end
 
-              current_module.type_params.add(
-                AST::Declarations::ModuleTypeParams::TypeParam.new(name: node.children[0],
-                                                                   variance: variance || :invariant,
-                                                                   skip_validation: false))
+              current_module.type_params << AST::TypeParam.new(
+                name: node.children[0],
+                variance: variance || :invariant,
+                location: nil,
+                upper_bound: nil
+              )
             end
           else
             name = node.children[0].yield_self do |n|

data/lib/rbs/prototype/runtime.rb

@@ -371,7 +371,7 @@ module RBS
         unless decl
           decl = AST::Declarations::Class.new(
             name: to_type_name(only_name(mod)),
-            type_params: AST::Declarations::ModuleTypeParams.empty,
+            type_params: [],
             super_class: generate_super_class(mod),
             members: [],
             annotations: [],
@@ -425,7 +425,7 @@ module RBS
         unless decl
           decl = AST::Declarations::Module.new(
             name: to_type_name(only_name(mod)),
-            type_params: AST::Declarations::ModuleTypeParams.empty,
+            type_params: [],
             self_types: [],
             members: [],
             annotations: [],
@@ -479,7 +479,7 @@ module RBS
             if outer_module.is_a?(Class)
               outer_decl = AST::Declarations::Class.new(
                 name: to_type_name(outer_module_name),
-                type_params: AST::Declarations::ModuleTypeParams.empty,
+                type_params: [],
                 super_class: generate_super_class(outer_module),
                 members: [],
                 annotations: [],
@@ -489,7 +489,7 @@ module RBS
             else
               outer_decl = AST::Declarations::Module.new(
                 name: to_type_name(outer_module_name),
-                type_params: AST::Declarations::ModuleTypeParams.empty,
+                type_params: [],
                 self_types: [],
                 members: [],
                 annotations: [],

data/lib/rbs/types.rb

@@ -26,6 +26,14 @@ module RBS
           enum_for :each_type
         end
       end
+
+      def map_type(&block)
+        if block
+          _ = self
+        else
+          enum_for(:map_type)
+        end
+      end
     end
 
     module Bases
@@ -261,6 +269,18 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Interface.new(
+            name: name,
+            args: args.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for(:map_type)
+        end
+      end
     end
 
     class ClassInstance
@@ -291,6 +311,18 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          ClassInstance.new(
+            name: name,
+            args: args.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Alias
@@ -319,6 +351,18 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Alias.new(
+            name: name,
+            args: args.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Tuple
@@ -379,6 +423,17 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Tuple.new(
+            types: types.map {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Record
@@ -444,6 +499,17 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Record.new(
+            fields: fields.transform_values {|type| yield type },
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Optional
@@ -503,6 +569,17 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Optional.new(
+            type: yield(type),
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Union
@@ -1046,6 +1123,18 @@ module RBS
           location: location
         )
       end
+
+      def map_type(&block)
+        if block
+          Proc.new(
+            type: type.map_type(&block),
+            block: self.block&.map_type(&block),
+            location: location
+          )
+        else
+          enum_for :map_type
+        end
+      end
     end
 
     class Literal

data/lib/rbs/validator.rb

@@ -27,19 +27,17 @@ module RBS
           end
         end
 
+        definition_builder.validate_type_name(type.name, type.location)
+
         type_params = case type
                       when Types::ClassInstance
-                        env.class_decls[type.name]&.type_params
+                        env.class_decls[type.name].type_params
                       when Types::Interface
-                        env.interface_decls[type.name]&.decl&.type_params
+                        env.interface_decls[type.name].decl.type_params
                       when Types::Alias
-                        env.alias_decls[type.name]&.decl&.type_params
+                        env.alias_decls[type.name].decl.type_params
                       end
 
-        unless type_params
-          raise NoTypeFoundError.new(type_name: type.name, location: type.location)
-        end
-
         InvalidTypeApplicationError.check!(
           type_name: type.name,
           args: type.args,
@@ -48,9 +46,7 @@ module RBS
         )
 
       when Types::ClassSingleton
-        # @type var type: Types::ClassSingleton
-        type = _ = absolute_type(type, context: context) { type.name.absolute! }
-        NoTypeFoundError.check!(type.name, env: env, location: type.location)
+        definition_builder.validate_type_presence(type)
       end
 
       type.each_type do |type|
@@ -76,7 +72,7 @@ module RBS
         result = calculator.in_type_alias(name: type_name)
         if set = result.incompatible?(entry.decl.type_params)
           set.each do |param_name|
-            param = entry.decl.type_params[param_name] or raise
+            param = entry.decl.type_params.find {|param| param.name == param_name } or raise
             raise InvalidVarianceAnnotationError.new(
               type_name: type_name,
               param: param,
@@ -84,6 +80,61 @@ module RBS
             )
           end
         end
+
+        validate_type_params(
+          entry.decl.type_params,
+          type_name: type_name,
+          location: entry.decl.location&.aref(:type_params)
+        )
+      end
+    end
+
+    def validate_method_definition(method_def, type_name:)
+      method_def.types.each do |method_type|
+        unless method_type.type_params.empty?
+          loc = method_type.location&.aref(:type_params)
+
+          validate_type_params(
+            method_type.type_params,
+            type_name: type_name,
+            method_name: method_def.name,
+            location: loc
+          )
+        end
+      end
+    end
+
+    def validate_type_params(params, type_name: , method_name: nil, location:)
+      # @type var each_node: TSort::_EachNode[Symbol]
+      each_node = __skip__ = -> (&block) do
+        params.each do |param|
+          block[param.name]
+        end
+      end
+      # @type var each_child: TSort::_EachChild[Symbol]
+      each_child = __skip__ = -> (name, &block) do
+        if param = params.find {|p| p.name == name }
+          if b = param.upper_bound
+            b.free_variables.each do |tv|
+              block[tv]
+            end
+          end
+        end
+      end
+
+      TSort.each_strongly_connected_component(each_node, each_child) do |names|
+        if names.size > 1
+          params = names.map do |name|
+            params.find {|param| param.name == name} or raise
+          end
+
+          raise CyclicTypeParameterBound.new(
+            type_name: type_name,
+            method_name: method_name,
+            params: params,
+            location: location
+          )
+        end
       end
     end
 

data/lib/rbs/variance_calculator.rb

@@ -141,14 +141,15 @@ module RBS
                       end
 
         type.args.each.with_index do |ty, i|
-          var = type_params.params[i]
-          case var&.variance
-          when :invariant
-            type(ty, result: result, context: :invariant)
-          when :covariant
-            type(ty, result: result, context: context)
-          when :contravariant
-            type(ty, result: result, context: negate(context))
+          if var = type_params[i]
+            case var.variance
+            when :invariant
+              type(ty, result: result, context: :invariant)
+            when :covariant
+              type(ty, result: result, context: context)
+            when :contravariant
+              type(ty, result: result, context: negate(context))
+            end
           end
         end
       when Types::Proc

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.8.0"
+  VERSION = "2.0.0"
 end

data/lib/rbs/writer.rb

@@ -146,19 +146,7 @@ module RBS
         "#{name}"
       else
         ps = params.each.map do |param|
-          s = ""
-          if param.skip_validation
-            s << "unchecked "
-          end
-          case param.variance
-          when :invariant
-            # nop
-          when :covariant
-            s << "out "
-          when :contravariant
-            s << "in "
-          end
-          s + param.name.to_s
+          param.to_s
         end
 
         "#{name}[#{ps.join(", ")}]"

data/lib/rbs.rb

@@ -16,6 +16,7 @@ require "rbs/namespace"
 require "rbs/type_name"
 require "rbs/types"
 require "rbs/method_type"
+require "rbs/ast/type_param"
 require "rbs/ast/declarations"
 require "rbs/ast/members"
 require "rbs/ast/annotation"

data/schema/decls.json

@@ -13,16 +13,10 @@
           "type": "string"
         },
         "type_params": {
-          "type": "object",
-          "properties": {
-            "params": {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/moduleTypeParam"
-              }
-            }
-          },
-          "required": ["params"]
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
         },
         "type": {
           "$ref": "types.json"
@@ -88,21 +82,6 @@
       },
       "required": ["declaration", "name", "type", "comment", "location"]
     },
-    "moduleTypeParam": {
-      "type": "object",
-      "properties": {
-        "name": {
-          "type": "string"
-        },
-        "variance": {
-          "enum": ["covariant", "contravariant", "invariant"]
-        },
-        "skip_validation": {
-          "type": "boolean"
-        }
-      },
-      "required": ["name", "variance", "skip_validation"]
-    },
     "classMember": {
       "oneOf": [
         {
@@ -157,16 +136,10 @@
           "type": "string"
         },
         "type_params": {
-          "type": "object",
-          "properties": {
-            "params": {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/moduleTypeParam"
-              }
-            }
-          },
-          "required": ["params"]
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
         },
         "members": {
           "type": "array",
@@ -221,16 +194,10 @@
           "type": "string"
         },
         "type_params": {
-          "type": "object",
-          "properties": {
-            "params": {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/moduleTypeParam"
-              }
-            }
-          },
-          "required": ["params"]
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
         },
         "members": {
           "type": "array",
@@ -309,16 +276,10 @@
           "type": "string"
         },
         "type_params": {
-          "type": "object",
-          "properties": {
-            "params": {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/moduleTypeParam"
-              }
-            }
-          },
-          "required": ["params"]
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
         },
         "members": {
           "type": "array",

data/schema/methodType.json

@@ -20,7 +20,7 @@
     "type_params": {
       "type": "array",
       "items": {
-        "type": "string"
+        "$ref": "typeParam.json"
       }
     },
     "type": {

data/schema/typeParam.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Type param: `A`, `unchecked out A`, ...",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "variance": {
+      "enum": ["covariant", "contravariant", "invariant"]
+    },
+    "unchecked": {
+      "type": "boolean"
+    },
+    "upper_bound": {
+      "oneOf": [
+        {
+          "$ref": "types.json#definitions/classInstance"
+        },
+        {
+          "$ref": "types.json#definitions/classSingleton"
+        },
+        {
+          "$ref": "types.json#definitions/interface"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "location": {
+      "$ref": "location.json"
+    }
+  },
+  "required": ["name", "variance", "unchecked", "upper_bound", "location"]
+}

data/sig/collection/collections.rbs

@@ -8,11 +8,15 @@ module RBS
         def versions: (Config::gem_entry) -> Array[String]
         def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
         def to_lockfile: () -> source_entry
+        def manifest_of: (Config::gem_entry) -> manifest_entry?
       end
 
       type source_entry = Git::source_entry
                             | Stdlib::source_entry
                             | Rubygems::source_entry
+      type manifest_entry = {
+        "dependencies" => Array[{"name" => String}]?,
+      }
 
       class Git
         METADATA_FILENAME: String
@@ -42,6 +46,8 @@ module RBS
 
         def to_lockfile: () -> source_entry
 
+        def manifest_of: (Config::gem_entry) -> manifest_entry?
+
         private
 
         def _install: (dest: Pathname , config_entry: Config::gem_entry) -> void
@@ -62,9 +68,9 @@ module RBS
 
         def resolve_revision: () -> String
 
-        def git: (*String cmd) -> String
+        def git: (*String cmd, **untyped opt) -> String
 
-        def sh!: (*String cmd) -> String
+        def sh!: (*String cmd, **untyped opt) -> String
 
         def format_config_entry: (Config::gem_entry) -> String
       end
@@ -86,6 +92,8 @@ module RBS
 
         def to_lockfile: () -> source_entry
 
+        def manifest_of: (Config::gem_entry) -> manifest_entry?
+
         private
 
         def gem_dir: (Config::gem_entry) -> Pathname
@@ -104,6 +112,7 @@ module RBS
         def versions: (Config::gem_entry) -> Array[String]
         def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
         def to_lockfile: () -> source_entry
+        def manifest_of: (Config::gem_entry) -> manifest_entry?
 
         private
 

data/sig/collection/config.rbs

@@ -16,7 +16,7 @@ module RBS
 
         private
 
-        def assign_gem: (gem_name: String, version: String?) -> void
+        def assign_gem: (name: String, version: String?) -> void
 
         def upsert_gem: (gem_entry? old, gem_entry new) -> void
 
@@ -24,7 +24,7 @@ module RBS
 
         def remove_ignored_gems!: () -> void
 
-        def find_source: (gem_name: String) -> untyped
+        def find_source: (name: String) -> untyped
 
         def find_best_version: (version: String?, versions: Array[String]) -> Gem::Version
       end