rbs 1.7.0 → 2.0.0.pre1

data/lib/rbs/ast/declarations.rb

@@ -4,103 +4,6 @@ module RBS
       class Base
       end
 
-      class ModuleTypeParams
-        attr_reader :params
-
-        TypeParam = _ = Struct.new(:name, :variance, :skip_validation, :location, keyword_init: true) do
-          # @implements TypeParam
-
-          def to_json(state = _ = nil)
-            {
-              name: name,
-              variance: variance,
-              skip_validation: skip_validation,
-            }.to_json(state)
-          end
-
-          def ==(other)
-            other.is_a?(TypeParam) &&
-              other.name == name &&
-              other.variance == variance &&
-              other.skip_validation == skip_validation
-          end
-
-          alias eql? ==
-
-          def hash
-            self.class.hash ^ name.hash ^ variance.hash ^ skip_validation.hash
-          end
-        end
-
-        def initialize()
-          @params = []
-        end
-
-        def add(param)
-          params << param
-          self
-        end
-
-        def ==(other)
-          other.is_a?(ModuleTypeParams) && other.params == params
-        end
-
-        alias eql? ==
-
-        def hash
-          params.hash
-        end
-
-        def [](name)
-          params.find {|p| p.name == name }
-        end
-
-        def to_json(state = _ = nil)
-          {
-            params: params
-          }.to_json(state)
-        end
-
-        def each(&block)
-          if block
-            params.each(&block)
-          else
-            params.each
-          end
-        end
-
-        def self.empty
-          new
-        end
-
-        def variance(name)
-          var = self[name] or raise
-          var.variance
-        end
-
-        def skip_validation?(name)
-          var = self[name] or raise
-          var.skip_validation
-        end
-
-        def empty?
-          params.empty?
-        end
-
-        def size
-          params.size
-        end
-
-        def rename_to(names)
-          ModuleTypeParams.new().tap do |params|
-            names.each.with_index do |new_name, index|
-              param = self.params[index]
-              params.add(TypeParam.new(name: new_name, variance: param.variance, skip_validation: param.skip_validation, location: param.location))
-            end
-          end
-        end
-      end
-
       module NestedDeclarationHelper
         def each_member
           if block_given?
@@ -362,13 +265,15 @@ module RBS
 
       class Alias < Base
         attr_reader :name
+        attr_reader :type_params
         attr_reader :type
         attr_reader :annotations
         attr_reader :location
         attr_reader :comment
 
-        def initialize(name:, type:, annotations:, location:, comment:)
+        def initialize(name:, type_params:, type:, annotations:, location:, comment:)
           @name = name
+          @type_params = type_params
           @type = type
           @annotations = annotations
           @location = location
@@ -378,19 +283,21 @@ module RBS
         def ==(other)
           other.is_a?(Alias) &&
             other.name == name &&
+            other.type_params == type_params &&
             other.type == type
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type.hash
+          self.class.hash ^ name.hash ^ type_params.hash ^ type.hash
         end
 
         def to_json(state = _ = nil)
           {
             declaration: :alias,
             name: name,
+            type_params: type_params,
             type: type,
             annotations: annotations,
             location: location,

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|
@@ -460,7 +490,7 @@ EOU
 
       env.alias_decls.each do |name, decl|
         stdout.puts "Validating alias: `#{name}`..."
-        builder.expand_alias(name).tap do |type|
+        builder.expand_alias1(name).tap do |type|
           validator.validate_type type, context: [Namespace.root]
         end
         validator.validate_type_alias(entry: decl)
@@ -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
@@ -104,9 +113,9 @@ module RBS
           else
             begin
               # git v2.27.0 or greater
-              git 'clone', '--filter=blob:none', remote, git_dir.to_s
+              git 'clone', '--filter=blob:none', remote, git_dir.to_s, chdir: nil
             rescue CommandError
-              git 'clone', remote, git_dir.to_s
+              git 'clone', remote, git_dir.to_s, chdir: nil
             end
           end
 
@@ -131,7 +140,8 @@ module RBS
         private def git_dir
           @git_dir ||= (
             base = Pathname(ENV['XDG_CACHE_HOME'] || File.expand_path("~/.cache"))
-            dir = base.join('rbs', Digest::SHA256.hexdigest(remote))
+            cache_key = remote.start_with?('.') ? "#{remote}\0#{Dir.pwd}" : remote
+            dir = base.join('rbs', Digest::SHA256.hexdigest(cache_key))
             dir.mkpath
             dir
           )
@@ -149,13 +159,14 @@ module RBS
           git('rev-parse', 'HEAD').chomp
         end
 
-        private def git(*cmd)
-          sh! 'git', *cmd
+        private def git(*cmd, **opt)
+          sh! 'git', *cmd, **opt
         end
 
-        private def sh!(*cmd)
+        private def sh!(*cmd, **opt)
           RBS.logger.debug "$ #{cmd.join(' ')}"
-          (__skip__ = Open3.capture3(*cmd, chdir: git_dir)).then do |out, err, status|
+          opt = { chdir: git_dir }.merge(opt).compact
+          (__skip__ = Open3.capture3(*cmd, **opt)).then do |out, err, status|
             raise CommandError, "Unexpected status #{status.exitstatus}\n\n#{err}" unless status.success?
 
             out

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

@@ -291,6 +291,10 @@ module RBS
             end
 
             one_ancestors.each_extended_module do |mod|
+              mod.args.each do |arg|
+                validate_type_presence(arg)
+              end
+
               mod_defn = build_instance(mod.name, no_self_types: true)
               merge_definition(src: mod_defn,
                                dest: definition,
@@ -299,6 +303,10 @@ module RBS
 
             interface_methods = {}
             one_ancestors.each_extended_interface do |mod|
+              mod.args.each do |arg|
+                validate_type_presence(arg)
+              end
+
               mod_defn = build_interface(mod.name)
               subst = Substitution.build(mod_defn.type_params, mod.args)
 
@@ -377,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
@@ -386,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,
@@ -438,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
@@ -781,9 +795,36 @@ module RBS
     end
 
     def expand_alias(type_name)
-      entry = env.alias_decls[type_name] or raise "Unknown name for expand_alias: #{type_name}"
+      expand_alias2(type_name, [])
+    end
+
+    def expand_alias1(type_name)
+      entry = env.alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
+      as = entry.decl.type_params.each.map { Types::Bases::Any.new(location: nil) }
+      expand_alias2(type_name, as)
+    end
+
+    def expand_alias2(type_name, args)
+      entry = env.alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
+
       ensure_namespace!(type_name.namespace, location: entry.decl.location)
-      entry.decl.type
+      params = entry.decl.type_params.each.map(&:name)
+
+      unless params.size == args.size
+        as = "[#{args.join(", ")}]" unless args.empty?
+        ps = "[#{params.join(", ")}]" unless params.empty?
+
+        raise "Invalid type application: type = #{type_name}#{as}, decl = #{type_name}#{ps}"
+      end
+
+      type = entry.decl.type
+
+      unless params.empty?
+        subst = Substitution.build(params, args)
+        type = type.sub(subst)
+      end
+
+      type
     end
 
     def update(env:, except:, ancestor_builder:)
@@ -804,5 +845,26 @@ module RBS
         end
       end
     end
+
+    def validate_type_presence(type)
+      case type
+      when Types::ClassInstance, Types::ClassSingleton, Types::Interface, Types::Alias
+        validate_type_name(type.name, type.location)
+      end
+
+      type.each_type do |type|
+        validate_type_presence(type)
+      end
+    end
+
+    def validate_type_name(name, location)
+      name = name.absolute!
+
+      return if name.class? && env.class_decls.key?(name)
+      return if name.interface? && env.interface_decls.key?(name)
+      return if name.alias? && env.alias_decls.key?(name)
+
+      raise NoTypeFoundError.new(type_name: name, location: location)
+    end
   end
 end