rbs 1.8.1 → 2.0.0.pre1

data/lib/rbs/ast/type_param.rb

@@ -0,0 +1,134 @@
+module RBS
+  module AST
+    class TypeParam
+      attr_reader :name, :variance, :location, :upper_bound
+
+      def initialize(name:, variance:, upper_bound:, location:)
+        @name = name
+        @variance = variance
+        @upper_bound = upper_bound
+        @location = location
+        @unchecked = false
+      end
+
+      def unchecked!(value = true)
+        @unchecked = value ? true : false
+        self
+      end
+
+      def unchecked?
+        @unchecked
+      end
+
+      def ==(other)
+        other.is_a?(TypeParam) &&
+          other.name == name &&
+          other.variance == variance &&
+          other.upper_bound == upper_bound &&
+          other.unchecked? == unchecked?
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ name.hash ^ variance.hash ^ upper_bound.hash ^ unchecked?.hash
+      end
+
+      def to_json(state = JSON::State.new)
+        {
+          name: name,
+          variance: variance,
+          unchecked: unchecked?,
+          location: location,
+          upper_bound: upper_bound
+        }.to_json(state)
+      end
+
+      def rename(name)
+        TypeParam.new(
+          name: name,
+          variance: variance,
+          upper_bound: upper_bound,
+          location: location
+        ).unchecked!(unchecked?)
+      end
+
+      def map_type(&block)
+        if b = upper_bound
+          _upper_bound = yield(b)
+        end
+
+        TypeParam.new(
+          name: name,
+          variance: variance,
+          upper_bound: _upper_bound,
+          location: location
+        ).unchecked!(unchecked?)
+      end
+
+      def self.resolve_variables(params)
+        return if params.empty?
+
+        vars = Set.new(params.map(&:name))
+
+        params.map! do |param|
+          param.map_type {|bound| _ = subst_var(vars, bound) }
+        end
+      end
+
+      def self.subst_var(vars, type)
+        case type
+        when Types::ClassInstance
+          namespace = type.name.namespace
+          if namespace.relative? && namespace.empty? && vars.member?(type.name.name)
+            return Types::Variable.new(name: type.name.name, location: type.location)
+          end
+        end
+
+        type.map_type {|t| subst_var(vars, t) }
+      end
+
+      def self.rename(params, new_names:)
+        raise unless params.size == new_names.size
+
+        subst = Substitution.build(new_names, Types::Variable.build(new_names))
+
+        params.map.with_index do |param, index|
+          new_name = new_names[index]
+
+          TypeParam.new(
+            name: new_name,
+            variance: param.variance,
+            upper_bound: param.upper_bound&.map_type {|type| type.sub(subst) },
+            location: param.location
+          ).unchecked!(param.unchecked?)
+        end
+      end
+
+      def to_s
+        s = ""
+
+        if unchecked?
+          s << "unchecked "
+        end
+
+        case variance
+        when :invariant
+          # nop
+        when :covariant
+          s << "out "
+        when :contravariant
+          s << "in "
+        end
+
+        s << name.to_s
+
+        if type = upper_bound
+          s << " < #{type}"
+        end
+
+        s
+      end
+    end
+  end
+end

data/lib/rbs/cli.rb

@@ -430,7 +430,7 @@ EOU
       builder = DefinitionBuilder.new(env: env)
       validator = Validator.new(env: env, resolver: TypeNameResolver.from_env(env))
 
-      env.class_decls.each_key do |name|
+      env.class_decls.each do |name, decl|
         stdout.puts "Validating class/module definition: `#{name}`..."
         builder.build_instance(name).each_type do |type|
           validator.validate_type type, context: [Namespace.root]
@@ -438,13 +438,43 @@ EOU
         builder.build_singleton(name).each_type do |type|
           validator.validate_type type, context: [Namespace.root]
         end
+
+        d = decl.primary.decl
+
+        validator.validate_type_params(
+          d.type_params,
+          type_name: name,
+          location: d.location&.aref(:type_params)
+        )
+
+        decl.decls.each do |d|
+          d.decl.each_member do |member|
+            case member
+            when AST::Members::MethodDefinition
+              validator.validate_method_definition(member, type_name: name)
+            end
+          end
+        end
       end
 
-      env.interface_decls.each_key do |name|
+      env.interface_decls.each do |name, decl|
         stdout.puts "Validating interface: `#{name}`..."
         builder.build_interface(name).each_type do |type|
           validator.validate_type type, context: [Namespace.root]
         end
+
+        validator.validate_type_params(
+          decl.decl.type_params,
+          type_name: name,
+          location: decl.decl.location&.aref(:type_params)
+        )
+
+        decl.decl.members.each do |member|
+          case member
+          when AST::Members::MethodDefinition
+            validator.validate_method_definition(member, type_name: name)
+          end
+        end
       end
 
       env.constant_decls.each do |name, const|
@@ -836,8 +866,6 @@ EOB
     end
 
     def run_collection(args, options)
-      warn "warning: rbs collection is experimental, and the behavior may change until RBS v2.0"
-
       opts = collection_options(args)
       params = {}
       opts.order args.drop(1), into: params

data/lib/rbs/collection/config/lockfile_generator.rb

@@ -15,15 +15,20 @@ module RBS
           @lock_path = Config.to_lockfile_path(config_path)
           @lock = Config.from_path(lock_path) if lock_path.exist? && with_lockfile
           @gemfile_lock = Bundler::LockfileParser.new(gemfile_lock_path.read)
+          @gem_queue = []
         end
 
         def generate
           config.gems.each do |gem|
-            assign_gem(gem_name: gem['name'], version: gem['version'])
+            @gem_queue.push({ name: gem['name'], version: gem['version'] })
           end
 
           gemfile_lock_gems do |spec|
-            assign_gem(gem_name: spec.name, version: spec.version)
+            @gem_queue.push({ name: spec.name, version: spec.version })
+          end
+
+          while gem = @gem_queue.shift
+            assign_gem(**gem)
           end
           remove_ignored_gems!
 
@@ -31,30 +36,33 @@ module RBS
           config
         end
 
-        private def assign_gem(gem_name:, version:)
-          locked = lock&.gem(gem_name)
-          specified = config.gem(gem_name)
+        private def assign_gem(name:, version:)
+          locked = lock&.gem(name)
+          specified = config.gem(name)
 
           return if specified&.dig('ignore')
           return if specified&.dig('source') # skip if the source is already filled
 
-          if locked
-            # If rbs_collection.lock.yaml contain the gem, use it.
-            upsert_gem specified, locked
-          else
-            # Find the gem from gem_collection.
-            source = find_source(gem_name: gem_name)
+          # If rbs_collection.lock.yaml contain the gem, use it.
+          # Else find the gem from gem_collection.
+          unless locked
+            source = find_source(name: name)
             return unless source
 
             installed_version = version
-            best_version = find_best_version(version: installed_version, versions: source.versions({ 'name' => gem_name }))
-            # @type var new_content: RBS::Collection::Config::gem_entry
-            new_content = {
-              'name' => gem_name,
+            best_version = find_best_version(version: installed_version, versions: source.versions({ 'name' => name }))
+            locked = {
+              'name' => name,
               'version' => best_version.to_s,
               'source' => source.to_lockfile,
             }
-            upsert_gem specified, new_content
+          end
+
+          upsert_gem specified, locked
+          source = Sources.from_config_entry(locked['source'])
+          manifest = source.manifest_of(locked) or return
+          manifest['dependencies']&.each do |dep|
+            @gem_queue.push({ name: dep['name'], version: nil} )
           end
         end
 
@@ -76,10 +84,10 @@ module RBS
           end
         end
 
-        private def find_source(gem_name:)
+        private def find_source(name:)
           sources = config.sources
 
-          sources.find { |c| c.has?({ 'name' => gem_name, 'revision' => nil } ) }
+          sources.find { |c| c.has?({ 'name' => name, 'revision' => nil } ) }
         end
 
         private def find_best_version(version:, versions:)

data/lib/rbs/collection/sources/git.rb

@@ -50,6 +50,15 @@ module RBS
           end
         end
 
+        def manifest_of(config_entry)
+          gem_name = config_entry['name']
+          version = config_entry['version'] or raise
+          gem_dir = gem_repo_dir.join(gem_name, version)
+
+          manifest_path = gem_dir.join('manifest.yaml')
+          YAML.safe_load(manifest_path.read) if manifest_path.exist?
+        end
+
         private def _install(dest:, config_entry:)
           gem_name = config_entry['name']
           version = config_entry['version'] or raise

data/lib/rbs/collection/sources/rubygems.rb

@@ -25,6 +25,13 @@ module RBS
           stdout.puts "Using #{name}:#{version} (#{from})"
         end
 
+        def manifest_of(config_entry)
+          _, sig_path = gem_sig_path(config_entry)
+          sig_path or raise
+          manifest_path = sig_path.join('manifest.yaml')
+          YAML.safe_load(manifest_path.read) if manifest_path.exist?
+        end
+
         def to_lockfile
           {
             'type' => 'rubygems',

data/lib/rbs/collection/sources/stdlib.rb

@@ -23,6 +23,12 @@ module RBS
           stdout.puts "Using #{name}:#{version} (#{from})"
         end
 
+        def manifest_of(config_entry)
+          version = config_entry['version'] or raise
+          manifest_path = gem_dir(config_entry).join(version, 'manifest.yaml')
+          YAML.safe_load(manifest_path.read) if manifest_path.exist?
+        end
+
         def to_lockfile
           {
             'type' => 'stdlib',

data/lib/rbs/definition.rb

@@ -155,6 +155,15 @@ module RBS
         )
       end
 
+      def map_type_bound(&block)
+        self.class.new(
+          super_method: super_method&.map_type_bound(&block),
+          defs: defs.map {|defn| defn.update(type: defn.type.map_type_bound(&block)) },
+          accessibility: @accessibility,
+          alias_of: alias_of
+        )
+      end
+
       def map_method_type(&block)
         self.class.new(
           super_method: super_method,

data/lib/rbs/definition_builder.rb

@@ -385,7 +385,7 @@ module RBS
                 initialize = instance.methods[:initialize]
 
                 if initialize
-                  class_params = entry.type_params.each.map(&:name)
+                  class_params = entry.type_params
 
                   # Inject a virtual _typed new_.
                   initialize_defs = initialize.defs
@@ -394,28 +394,34 @@ module RBS
                     defs: initialize_defs.map do |initialize_def|
                       method_type = initialize_def.type
 
-                      class_type_param_vars = Set.new(class_params)
-                      method_type_param_vars = Set.new(method_type.type_params)
+                      class_type_param_vars = Set.new(class_params.map(&:name))
+                      method_type_param_vars = Set.new(method_type.type_params.map(&:name))
 
                       if class_type_param_vars.intersect?(method_type_param_vars)
-                        renamed_method_params = method_type.type_params.map do |name|
-                          if class_type_param_vars.include?(name)
-                            Types::Variable.fresh(name).name
+                        new_method_param_names = method_type.type_params.map do |method_param|
+                          if class_type_param_vars.include?(method_param.name)
+                            Types::Variable.fresh(method_param.name).name
                           else
-                            name
+                            method_param.name
                           end
                         end
-                        method_params = class_params + renamed_method_params
 
-                        sub = Substitution.build(method_type.type_params, Types::Variable.build(renamed_method_params))
+                        sub = Substitution.build(
+                          method_type.type_params.map(&:name),
+                          Types::Variable.build(new_method_param_names)
+                        )
+
+                        method_params = class_params + AST::TypeParam.rename(method_type.type_params, new_names: new_method_param_names)
+                        method_type = method_type
+                          .update(type_params: [])
+                          .sub(sub)
+                          .update(type_params: method_params)
                       else
-                        method_params = class_params + method_type.type_params
-                        sub = Substitution.build([], [])
+                        method_type = method_type
+                          .update(type_params: class_params + method_type.type_params)
                       end
 
-                      method_type = method_type.map_type {|ty| ty.sub(sub) }
                       method_type = method_type.update(
-                        type_params: method_params,
                         type: method_type.type.with_return_type(
                           Types::ClassInstance.new(
                             name: type_name,
@@ -446,7 +452,7 @@ module RBS
 
     def validate_params_with(type_params, result:)
       type_params.each do |param|
-        unless param.skip_validation
+        unless param.unchecked?
           unless result.compatible?(param.name, with_annotation: param.variance)
             yield param
           end

data/lib/rbs/environment.rb

@@ -39,22 +39,29 @@ module RBS
 
       def validate_type_params
         unless decls.empty?
+          # @type var hd_decl: MultiEntry::D[module_decl]
+          # @type var tl_decls: Array[MultiEntry::D[module_decl]]
           hd_decl, *tl_decls = decls
           raise unless hd_decl
 
           hd_params = hd_decl.decl.type_params
-          hd_names = hd_params.params.map(&:name)
 
           tl_decls.each do |tl_decl|
             tl_params = tl_decl.decl.type_params
 
-            unless hd_params.size == tl_params.size && hd_params == tl_params.rename_to(hd_names)
+            unless compatible_params?(hd_params, tl_params)
               raise GenericParameterMismatchError.new(name: name, decl: tl_decl.decl)
             end
           end
         end
       end
 
+      def compatible_params?(ps1, ps2)
+        if ps1.size == ps2.size
+          ps1 == AST::TypeParam.rename(ps2, new_names: ps1.map(&:name))
+        end
+      end
+
       def type_params
         primary.decl.type_params
       end
@@ -240,17 +247,19 @@ module RBS
         array.unshift(head + decl.name.to_namespace)
       end
 
+      outer_context = context.drop(1)
+
       case decl
       when AST::Declarations::Class
         outer_ = outer + [decl]
         prefix_ = prefix + decl.name.to_namespace
         AST::Declarations::Class.new(
           name: decl.name.with_prefix(prefix),
-          type_params: decl.type_params,
+          type_params: resolve_type_params(resolver, decl.type_params, context: context),
           super_class: decl.super_class&.yield_self do |super_class|
             AST::Declarations::Class::Super.new(
-              name: absolute_type_name(resolver, super_class.name, context: context),
-              args: super_class.args.map {|type| absolute_type(resolver, type, context: context) },
+              name: absolute_type_name(resolver, super_class.name, context: outer_context),
+              args: super_class.args.map {|type| absolute_type(resolver, type, context: outer_context) },
               location: super_class.location
             )
           end,
@@ -278,7 +287,7 @@ module RBS
         prefix_ = prefix + decl.name.to_namespace
         AST::Declarations::Module.new(
           name: decl.name.with_prefix(prefix),
-          type_params: decl.type_params,
+          type_params: resolve_type_params(resolver, decl.type_params, context: context),
           self_types: decl.self_types.map do |module_self|
             AST::Declarations::Module::Self.new(
               name: absolute_type_name(resolver, module_self.name, context: context),
@@ -308,7 +317,7 @@ module RBS
       when AST::Declarations::Interface
         AST::Declarations::Interface.new(
           name: decl.name.with_prefix(prefix),
-          type_params: decl.type_params,
+          type_params: resolve_type_params(resolver, decl.type_params, context: context),
           members: decl.members.map do |member|
             resolve_member(resolver, member, context: context)
           end,
@@ -319,7 +328,7 @@ module RBS
       when AST::Declarations::Alias
         AST::Declarations::Alias.new(
           name: decl.name.with_prefix(prefix),
-          type_params: decl.type_params,
+          type_params: resolve_type_params(resolver, decl.type_params, context: context),
           type: absolute_type(resolver, decl.type, context: context),
           location: decl.location,
           annotations: decl.annotations,
@@ -343,7 +352,7 @@ module RBS
           name: member.name,
           kind: member.kind,
           types: member.types.map do |type|
-            type.map_type {|ty| absolute_type(resolver, ty, context: context) }
+            resolve_method_type(resolver, type, context: context)
           end,
           comment: member.comment,
           overload: member.overload?,
@@ -430,6 +439,20 @@ module RBS
       end
     end
 
+    def resolve_method_type(resolver, type, context:)
+      type.map_type do |ty|
+        absolute_type(resolver, ty, context: context)
+      end.map_type_bound do |bound|
+        _ = absolute_type(resolver, bound, context: context)
+      end
+    end
+
+    def resolve_type_params(resolver, params, context:)
+      params.map do |param|
+        param.map_type {|type| _ = absolute_type(resolver, type, context: context) }
+      end
+    end
+
     def absolute_type_name(resolver, type_name, context:)
       resolver.resolve(type_name, context: context) || type_name
     end

data/lib/rbs/environment_loader.rb

@@ -48,8 +48,6 @@ module RBS
     end
 
     def add_collection(collection_config)
-      warn "warning: rbs collection is experimental, and the behavior may change until RBS v2.0"
-
       collection_config.check_rbs_availability!
 
       repository.add(collection_config.repo_path)

data/lib/rbs/errors.rb

@@ -14,11 +14,11 @@ module RBS
     end
   end
 
-  class ErrorBase < StandardError; end
-  class LoadingError < ErrorBase; end
-  class DefinitionError < ErrorBase; end
+  class BaseError < StandardError; end
+  class LoadingError < BaseError; end
+  class DefinitionError < BaseError; end
 
-  class ParsingError < ErrorBase
+  class ParsingError < BaseError
     attr_reader :location
     attr_reader :error_message
     attr_reader :token_type
@@ -105,7 +105,7 @@ module RBS
     end
   end
 
-  class NoTypeFoundError < ErrorBase
+  class NoTypeFoundError < BaseError
     attr_reader :type_name
     attr_reader :location
 
@@ -416,7 +416,7 @@ module RBS
     end
   end
 
-  class RecursiveTypeAliasError < LoadingError
+  class RecursiveTypeAliasError < BaseError
     attr_reader :alias_names
     attr_reader :location
 
@@ -432,7 +432,7 @@ module RBS
     end
   end
 
-  class NonregularTypeAliasError < LoadingError
+  class NonregularTypeAliasError < BaseError
     attr_reader :diagnostic
     attr_reader :location
 
@@ -443,4 +443,17 @@ module RBS
       super "#{Location.to_string location}: Nonregular generic type alias is prohibited: #{diagnostic.type_name}, #{diagnostic.nonregular_type}"
     end
   end
+
+  class CyclicTypeParameterBound < BaseError
+    attr_reader :params, :type_name, :method_name, :location
+
+    def initialize(type_name:, method_name:, params:, location:)
+      @type_name = type_name
+      @method_name = method_name
+      @params = params
+      @location = location
+
+      super "#{Location.to_string(location)}: Cyclic type parameter bound is prohibited"
+    end
+  end
 end

data/lib/rbs/location_aux.rb

@@ -17,6 +17,8 @@ module RBS
         end
     end
 
+    alias aref []
+
     WithChildren = self
 
     def name

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: [],