rbs 3.0.0.dev.1 → 3.0.0.dev.2

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}"
+
+      if const_name.absolute?
+        constant = resolver.table.constant(const_name)
+      else
+        head, *components = const_name.to_namespace.path
+        head or raise
 
-      constant = table.resolve_constant_reference(name, context: namespace.ascend.to_a)
+        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?

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)
 
@@ -99,9 +107,8 @@ module RBS
               if src_data
                 Sources.from_config_entry(src_data)
               else
-                find_source(name: name)
+                find_source(name: name) or return
               end
-            return unless source
 
             installed_version = version
             best_version = find_best_version(version: installed_version, versions: source.versions(name))
@@ -116,11 +123,15 @@ module RBS
           locked or raise
 
           lockfile.gems[name] = locked
-          source = locked[:source]
 
-          source.dependencies_of(locked[:name], locked[:version])&.each do |dep|
+          locked[:source].dependencies_of(locked[:name], locked[:version])&.each do |dep|
             assign_stdlib(name: dep["name"], from_gem: name)
           end
+
+          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
 
         private def assign_stdlib(name:, from_gem:)
@@ -150,12 +161,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

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

@@ -171,7 +171,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/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

data/lib/rbs/environment/use_map.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RBS
+  class Environment
+    class UseMap
+      class Table
+        attr_reader :known_types, :children
+
+        def initialize
+          @known_types = Set[]
+          @children = {}
+        end
+
+        def compute_children
+          children.clear
+
+          known_types.each do |type|
+            unless type.namespace.empty?
+              children[type.namespace] ||= Set[]
+              children[type.namespace] << type
+            end
+          end
+
+          self
+        end
+      end
+
+      attr_reader :use_dirs
+
+      def initialize(table:)
+        @use_dirs = []
+        @map = {}
+        @table = table
+      end
+
+      def build_map(clause)
+        case clause
+        when AST::Directives::Use::SingleClause
+          if clause.new_name
+            @map[clause.new_name] = clause.type_name.absolute!
+          else
+            @map[clause.type_name.name] = clause.type_name.absolute!
+          end
+        when AST::Directives::Use::WildcardClause
+          @table.children.fetch(clause.namespace.absolute!).each do |child|
+            @map[child.name] = child
+          end
+        end
+
+        self
+      end
+
+      def resolve?(type_name)
+        return if type_name.absolute?
+
+        hd, *tl = type_name.namespace.path
+
+        if hd
+          # namespace is not empty
+          if tn = @map[hd]
+            path = [*tn.namespace.path, tn.name, *tl]
+            TypeName.new(
+              namespace: Namespace.new(absolute: true, path: path),
+              name: type_name.name
+            )
+          end
+        else
+          @map[type_name.name]
+        end
+      end
+
+      def resolve(type_name)
+        resolve?(type_name) || type_name
+      end
+    end
+  end
+end