rbs 3.0.0.dev.1 → 3.0.0.dev.3

data/lib/rbs/ast/directives.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Directives
+      class Base
+      end
+
+      class Use < Base
+        class SingleClause
+          attr_reader :type_name, :new_name, :location
+
+          def initialize(type_name:, new_name:, location:)
+            @type_name = type_name
+            @new_name = new_name
+            @location = location
+          end
+        end
+
+        class WildcardClause
+          attr_reader :namespace, :location
+
+          def initialize(namespace:, location:)
+            @location = location
+            @namespace = namespace
+          end
+        end
+
+        attr_reader :clauses, :location
+
+        def initialize(clauses:, location:)
+          @clauses = clauses
+          @location = location
+        end
+      end
+
+    end
+  end
+end

data/lib/rbs/cli.rb

@@ -438,15 +438,15 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      validator = Validator.new(env: env, resolver: TypeNameResolver.from_env(env))
+      validator = Validator.new(env: env, resolver: Resolver::TypeNameResolver.new(env))
 
       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]
+          validator.validate_type type, context: nil
         end
         builder.build_singleton(name).each_type do |type|
-          validator.validate_type type, context: [Namespace.root]
+          validator.validate_type type, context: nil
         end
 
         d = decl.primary.decl
@@ -467,10 +467,15 @@ EOU
         end
       end
 
+      env.class_alias_decls.each do |name, entry|
+        stdout.puts "Validating class/module alias definition: `#{name}`..."
+        validator.validate_class_alias(entry: entry)
+      end
+
       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]
+          validator.validate_type type, context: nil
         end
 
         validator.validate_type_params(
@@ -495,13 +500,13 @@ EOU
 
       env.global_decls.each do |name, global|
         stdout.puts "Validating global: `#{name}`..."
-        validator.validate_type global.decl.type, context: [Namespace.root]
+        validator.validate_type global.decl.type, context: nil
       end
 
-      env.alias_decls.each do |name, decl|
+      env.type_alias_decls.each do |name, decl|
         stdout.puts "Validating alias: `#{name}`..."
         builder.expand_alias1(name).tap do |type|
-          validator.validate_type type, context: [Namespace.root]
+          validator.validate_type type, context: nil
         end
         validator.validate_type_alias(entry: decl)
       end
@@ -537,14 +542,26 @@ EOU
       env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
-      table = ConstantTable.new(builder: builder)
+      resolver = Resolver::ConstantResolver.new(builder: builder)
 
-      namespace = context ? Namespace.parse(context).absolute! : Namespace.root
-      stdout.puts "Context: #{namespace}"
-      name = Namespace.parse(args[0]).to_type_name
-      stdout.puts "Constant name: #{name}"
+      resolver_context = context ? [nil, TypeName(context).absolute!] : nil #: Resolver::context
+      stdout.puts "Context: #{context}"
+      const_name = TypeName(args[0])
+      stdout.puts "Constant name: #{const_name}"
 
-      constant = table.resolve_constant_reference(name, context: namespace.ascend.to_a)
+      if const_name.absolute?
+        constant = resolver.table.constant(const_name)
+      else
+        head, *components = const_name.to_namespace.path
+        head or raise
+
+        constant = resolver.resolve(head, context: resolver_context)
+        constant = components.inject(constant) do |const, component|
+          if const
+            resolver.resolve_child(const.name, component)
+          end
+        end
+      end
 
       if constant
         stdout.puts " => #{constant.name}: #{constant.type}"
@@ -1043,15 +1060,12 @@ EOB
       case args[0]
       when 'install'
         unless params[:frozen]
-          gemfile_lock_path = Bundler.default_lockfile
-          Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: gemfile_lock_path)
+          Collection::Config.generate_lockfile(config_path: config_path, definition: Bundler.definition)
         end
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
       when 'update'
-        gemfile_lock_path = Bundler.default_lockfile
-
         # TODO: Be aware of argv to update only specified gem
-        Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: gemfile_lock_path, with_lockfile: false)
+        Collection::Config.generate_lockfile(config_path: config_path, definition: Bundler.definition, with_lockfile: false)
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
       when 'init'
         if config_path.exist?
@@ -1062,11 +1076,16 @@ EOB
         config_path.write(<<~'YAML')
           # Download sources
           sources:
-            - name: ruby/gem_rbs_collection
+            - type: git
+              name: ruby/gem_rbs_collection
               remote: https://github.com/ruby/gem_rbs_collection.git
               revision: main
               repo_dir: gems
 
+          # You can specify local directories as sources also.
+          # - type: local
+          #   path: path/to/your/local/repository
+
           # A directory to install the downloaded RBSs
           path: .gem_rbs_collection
 

data/lib/rbs/collection/cleaner.rb

@@ -16,7 +16,14 @@ module RBS
           version or raise
           next if needed? gem_name, version
 
-          FileUtils.remove_entry_secure(dir.to_s)
+          case
+          when dir.symlink?
+            dir.unlink
+          when dir.directory?
+            FileUtils.remove_entry_secure(dir.to_s)
+          else
+            raise
+          end
         end
       end
 

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

@@ -75,7 +75,7 @@ module RBS
           if gems = data["gems"]
             gems.each do |gem|
               src = gem["source"]
-              source = Sources.from_config_entry(src)
+              source = Sources.from_config_entry(src, base_directory: lockfile_path.dirname)
               lockfile.gems[gem["name"]] = {
                 name: gem["name"],
                 version: gem["version"],
@@ -106,6 +106,8 @@ module RBS
               meta_path = fullpath.join(gem[:name], gem[:version], Sources::Git::METADATA_FILENAME)
               raise CollectionNotAvailable unless meta_path.exist?
               raise CollectionNotAvailable unless library_data(gem) == YAML.load(meta_path.read)
+            when Sources::Local
+              raise CollectionNotAvailable unless fullpath.join(gem[:name], gem[:version]).symlink?
             end
           end
         end

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

@@ -20,15 +20,15 @@ module RBS
           end
         end
 
-        attr_reader :config, :lockfile, :gemfile_lock, :existing_lockfile
+        attr_reader :config, :lockfile, :definition, :existing_lockfile, :gem_hash
 
-        def self.generate(config:, gemfile_lock_path:, with_lockfile: true)
-          generator = new(config: config, gemfile_lock_path: gemfile_lock_path, with_lockfile: with_lockfile)
+        def self.generate(config:, definition:, with_lockfile: true)
+          generator = new(config: config, definition: definition, with_lockfile: with_lockfile)
           generator.generate
           generator.lockfile
         end
 
-        def initialize(config:, gemfile_lock_path:, with_lockfile:)
+        def initialize(config:, definition:, with_lockfile:)
           @config = config
 
           lockfile_path = Config.to_lockfile_path(config.config_path)
@@ -37,7 +37,7 @@ module RBS
           @lockfile = Lockfile.new(
             lockfile_path: lockfile_path,
             path: config.repo_path_data,
-            gemfile_lock_path: gemfile_lock_path.relative_path_from(lockfile_dir)
+            gemfile_lock_path: definition.lockfile.relative_path_from(lockfile_dir)
           )
           config.sources.each do |source|
             case source
@@ -48,10 +48,13 @@ module RBS
 
           if with_lockfile && lockfile_path.file?
             @existing_lockfile = Lockfile.from_lockfile(lockfile_path: lockfile_path, data: YAML.load_file(lockfile_path.to_s))
-            validate_gemfile_lock_path!(lock: @existing_lockfile, gemfile_lock_path: gemfile_lock_path)
+            validate_gemfile_lock_path!(lock: @existing_lockfile, gemfile_lock_path: definition.lockfile)
           end
 
-          @gemfile_lock = Bundler::LockfileParser.new(gemfile_lock_path.read)
+          @definition = definition
+          @gem_hash = definition.locked_gems.specs.each.with_object({}) do |spec, hash|  #$ Hash[String, Bundler::LazySpecification]
+            hash[spec.name] = spec
+          end
         end
 
         def generate
@@ -67,8 +70,13 @@ module RBS
             end
           end
 
-          gemfile_lock_gems do |spec|
-            assign_gem(name: spec.name, version: spec.version, ignored_gems: ignored_gems, src_data: nil)
+          definition.dependencies.each do |dep|
+            if dep.autorequire && dep.autorequire.empty?
+              next
+            end
+
+            spec = gem_hash[dep.name] or raise "Cannot find `#{dep.name}` in bundler context"
+            assign_gem(name: dep.name, version: spec.version, ignored_gems: ignored_gems, src_data: nil)
           end
 
           lockfile.lockfile_path.write(YAML.dump(lockfile.to_lockfile))
@@ -82,7 +90,7 @@ module RBS
           end
         end
 
-        private def assign_gem(name:, version:, ignored_gems:, src_data:)
+        private def assign_gem(name:, version:, src_data:, ignored_gems:)
           return if ignored_gems.include?(name)
           return if lockfile.gems.key?(name)
 
@@ -97,29 +105,34 @@ module RBS
           unless locked
             source =
               if src_data
-                Sources.from_config_entry(src_data)
+                Sources.from_config_entry(src_data, base_directory: config.config_path.dirname)
               else
                 find_source(name: name)
               end
-            return unless source
 
-            installed_version = version
-            best_version = find_best_version(version: installed_version, versions: source.versions(name))
+            if source
+              installed_version = version
+              best_version = find_best_version(version: installed_version, versions: source.versions(name))
 
-            locked = {
-              name: name,
-              version: best_version.to_s,
-              source: source,
-            }
+              locked = {
+                name: name,
+                version: best_version.to_s,
+                source: source,
+              }
+            end
           end
 
-          locked or raise
+          if locked
+            lockfile.gems[name] = locked
 
-          lockfile.gems[name] = locked
-          source = locked[:source]
+            locked[:source].dependencies_of(locked[:name], locked[:version])&.each do |dep|
+              assign_stdlib(name: dep["name"], from_gem: name)
+            end
+          end
 
-          source.dependencies_of(locked[:name], locked[:version])&.each do |dep|
-            assign_stdlib(name: dep["name"], from_gem: name)
+          gem_hash[name].dependencies.each do |dep|
+            spec = gem_hash[dep.name]
+            assign_gem(name: dep.name, version: spec.version, src_data: nil, ignored_gems: ignored_gems)
           end
         end
 
@@ -150,12 +163,6 @@ module RBS
           end
         end
 
-        private def gemfile_lock_gems(&block)
-          gemfile_lock.specs.each do |spec|
-            yield spec
-          end
-        end
-
         private def find_source(name:)
           sources = config.sources
 

data/lib/rbs/collection/config.rb

@@ -31,9 +31,9 @@ module RBS
 
       # Generate a rbs lockfile from Gemfile.lock to `config_path`.
       # If `with_lockfile` is true, it respects existing rbs lockfile.
-      def self.generate_lockfile(config_path:, gemfile_lock_path:, with_lockfile: true)
+      def self.generate_lockfile(config_path:, definition:, with_lockfile: true)
         config = from_path(config_path)
-        lockfile = LockfileGenerator.generate(config: config, gemfile_lock_path: gemfile_lock_path, with_lockfile: with_lockfile)
+        lockfile = LockfileGenerator.generate(config: config, definition: definition, with_lockfile: with_lockfile)
 
         [config, lockfile]
       end
@@ -66,7 +66,7 @@ module RBS
       def sources
         @sources ||= (
           @data['sources']
-            .map { |c| Sources.from_config_entry(c) }
+            .map { |c| Sources.from_config_entry(c, base_directory: @config_path.dirname) }
             .push(Sources::Stdlib.instance)
             .push(Sources::Rubygems.instance)
         )

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

@@ -45,7 +45,12 @@ module RBS
 
           gem_dir = dest.join(name, version)
 
-          if gem_dir.directory?
+          case
+          when gem_dir.symlink?
+            stdout.puts "Updating to #{format_config_entry(name, version)} from a local source"
+            gem_dir.unlink
+            _install(dest: dest, name: name, version: version)
+          when gem_dir.directory?
             prev = load_metadata(dir: gem_dir)
 
             if prev == metadata_content(name: name, version: version)
@@ -55,9 +60,11 @@ module RBS
               FileUtils.remove_entry_secure(gem_dir.to_s)
               _install(dest: dest, name: name, version: version)
             end
-          else
+          when !gem_dir.exist?
             stdout.puts "Installing #{format_config_entry(name, version)}"
             _install(dest: dest, name: name, version: version)
+          else
+            raise
           end
         end
 
@@ -171,7 +178,7 @@ module RBS
               if commit_hash?
                 revision
               else
-                setup! { git('rev-parse', revision).chomp }
+                setup! { git('rev-parse', "refs/remotes/origin/#{revision}").chomp }
               end
             end
         end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+    module Sources
+      class Local
+        include Base
+
+        attr_reader :path, :full_path
+  
+        def initialize(path:, base_directory:)
+          # TODO: resolve relative path from dir of rbs_collection.yaml
+          @path = Pathname(path)
+          @full_path = base_directory / path
+        end
+
+        def has?(name, version)
+          if version
+            @full_path.join(name, version).directory?
+          else
+            not versions(name).empty?
+          end
+        end
+
+        def versions(name)
+          @full_path.join(name).glob('*/').map { |path| path.basename.to_s }
+        end
+
+        # Create a symlink instead of copying file to refer files in @path.
+        # By avoiding copying RBS files, the users do not need re-run `rbs collection install`
+        # when the RBS files are updated.
+        def install(dest:, name:, version:, stdout:)
+          from = @full_path.join(name, version)
+          gem_dir = dest.join(name, version)
+
+          case
+          when gem_dir.symlink? && gem_dir.readlink == from
+            stdout.puts "Using #{name}:#{version} (#{from})"
+          when gem_dir.symlink?
+            prev = gem_dir.readlink
+            gem_dir.unlink
+            _install(from, dest.join(name, version))
+            stdout.puts "Updating #{name}:#{version} to #{from} from #{prev}"
+          when gem_dir.directory?
+            # TODO: Show version of git source
+            FileUtils.remove_entry_secure(gem_dir.to_s)
+            _install(from, dest.join(name, version))
+            stdout.puts "Updating #{name}:#{version} from git source"
+          when !gem_dir.exist?
+            _install(from, dest.join(name, version))
+            stdout.puts "Installing #{name}:#{version} (#{from})"
+          else
+            raise
+          end
+        end
+
+        private def _install(src, dst)
+          dst.dirname.mkpath
+          File.symlink(src, dst)
+        end
+
+        def manifest_of(name, version)
+          gem_dir = @full_path.join(name, version)
+          raise unless gem_dir.exist?
+
+          manifest_path = gem_dir.join('manifest.yaml')
+          YAML.safe_load(manifest_path.read) if manifest_path.exist?
+        end
+
+        def to_lockfile
+          {
+            'type' => 'local',
+            'path' => @path.to_s,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rbs/collection/sources.rb

@@ -4,11 +4,12 @@ require_relative './sources/base'
 require_relative './sources/git'
 require_relative './sources/stdlib'
 require_relative './sources/rubygems'
+require_relative './sources/local'
 
 module RBS
   module Collection
     module Sources
-      def self.from_config_entry(source_entry)
+      def self.from_config_entry(source_entry, base_directory:)
         case source_entry['type']
         when 'git', nil # git source by default
           # @type var source_entry: Git::source_entry
@@ -18,6 +19,12 @@ module RBS
             remote: source_entry["remote"],
             repo_dir: source_entry["repo_dir"]
           )
+        when 'local'
+          # @type var source_entry: Local::source_entry
+          Local.new(
+            path: source_entry['path'],
+            base_directory: base_directory,
+          )
         when 'stdlib'
           Stdlib.instance
         when 'rubygems'

data/lib/rbs/definition_builder/ancestor_builder.rb

@@ -190,6 +190,8 @@ module RBS
       end
 
       def one_instance_ancestors(type_name)
+        type_name = env.normalize_module_name(type_name)
+
         as = one_instance_ancestors_cache[type_name] and return as
 
         entry = env.class_decls[type_name] or raise "Unknown name for one_instance_ancestors: #{type_name}"
@@ -210,6 +212,8 @@ module RBS
               super_args = []
             end
 
+            super_name = env.normalize_module_name(super_name)
+
             NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
             if super_class
               InheritModuleError.check!(super_class, env: env)
@@ -236,7 +240,12 @@ module RBS
           else
             entry.self_types.each do |module_self|
               NoSelfTypeFoundError.check!(module_self, env: env)
-              self_types.push Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args, source: module_self)
+
+              module_name = module_self.name
+              if module_name.class?
+                module_name = env.normalize_module_name(module_name)
+              end
+              self_types.push Definition::Ancestor::Instance.new(name: module_name, args: module_self.args, source: module_self)
             end
           end
         end
@@ -253,6 +262,7 @@ module RBS
       end
 
       def one_singleton_ancestors(type_name)
+        type_name = env.normalize_module_name(type_name)
         as = one_singleton_ancestors_cache[type_name] and return as
 
         entry = env.class_decls[type_name] or raise "Unknown name for one_singleton_ancestors: #{type_name}"
@@ -270,6 +280,8 @@ module RBS
               super_name = BuiltinNames::Object.name
             end
 
+            super_name = env.normalize_module_name(super_name)
+
             NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
             if super_class
               InheritModuleError.check!(super_class, env: env)
@@ -328,16 +340,18 @@ module RBS
           when AST::Members::Include
             module_name = member.name
             module_args = member.args.map {|type| align_params ? type.sub(align_params) : type }
-            ancestor = Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
 
             case
             when member.name.class? && included_modules
               MixinClassError.check!(type_name: type_name, env: env, member: member)
               NoMixinFoundError.check!(member.name, env: env, member: member)
-              included_modules << ancestor
+
+              module_name = env.normalize_module_name(module_name)
+              included_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
             when member.name.interface? && included_interfaces
               NoMixinFoundError.check!(member.name, env: env, member: member)
-              included_interfaces << ancestor
+
+              included_interfaces << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
             end
 
           when AST::Members::Prepend
@@ -345,7 +359,7 @@ module RBS
               MixinClassError.check!(type_name: type_name, env: env, member: member)
               NoMixinFoundError.check!(member.name, env: env, member: member)
 
-              module_name = member.name
+              module_name = env.normalize_module_name(member.name)
               module_args = member.args.map {|type| align_params ? type.sub(align_params) : type }
 
               prepended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
@@ -354,16 +368,18 @@ module RBS
           when AST::Members::Extend
             module_name = member.name
             module_args = member.args
-            ancestor = Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
 
             case
             when member.name.class? && extended_modules
               MixinClassError.check!(type_name: type_name, env: env, member: member)
               NoMixinFoundError.check!(member.name, env: env, member: member)
-              extended_modules << ancestor
+
+              module_name = env.normalize_module_name(module_name)
+              extended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
             when member.name.interface? && extended_interfaces
               NoMixinFoundError.check!(member.name, env: env, member: member)
-              extended_interfaces << ancestor
+
+              extended_interfaces << Definition::Ancestor::Instance.new(name: module_name, args: module_args, source: member)
             end
           end
         end

data/lib/rbs/definition_builder.rb

@@ -3,7 +3,6 @@
 module RBS
   class DefinitionBuilder
     attr_reader :env
-    attr_reader :type_name_resolver
     attr_reader :ancestor_builder
     attr_reader :method_builder
 
@@ -14,7 +13,6 @@ module RBS
 
     def initialize(env:, ancestor_builder: nil, method_builder: nil)
       @env = env
-      @type_name_resolver = TypeNameResolver.from_env(env)
       @ancestor_builder = ancestor_builder || AncestorBuilder.new(env: env)
       @method_builder = method_builder || MethodBuilder.new(env: env)
 
@@ -72,7 +70,7 @@ module RBS
           entry = env.interface_decls[name] or raise "Unknown interface name: #{name}"
           entry.decl.type_params
         when name.alias?
-          entry = env.alias_decls[name] or raise "Unknown alias name: #{name}"
+          entry = env.type_alias_decls[name] or raise "Unknown alias name: #{name}"
           entry.decl.type_params
         when name.class?
           entry = env.class_decls[name] or raise "Unknown module name: #{name}"
@@ -150,6 +148,8 @@ module RBS
     end
 
     def build_instance(type_name)
+      type_name = env.normalize_module_name(type_name)
+
       try_cache(type_name, cache: instance_cache) do
         entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
         ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
@@ -278,6 +278,8 @@ module RBS
     end
 
     def build_singleton(type_name)
+      type_name = env.normalize_module_name(type_name)
+      
       try_cache type_name, cache: singleton_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
         ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
@@ -743,13 +745,13 @@ module RBS
     end
 
     def expand_alias1(type_name)
-      entry = env.alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
+      entry = env.type_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}"
+      entry = env.type_alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
 
       ensure_namespace!(type_name.namespace, location: entry.decl.location)
       params = entry.decl.type_params.each.map(&:name)
@@ -803,9 +805,7 @@ module RBS
     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)
+      return if env.type_name?(name)
 
       raise NoTypeFoundError.new(type_name: name, location: location)
     end