rbs 2.8.4 → 3.0.0.dev.2

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

@@ -12,25 +12,22 @@ module RBS
 
         REPO = Repository.default
 
-        def has?(config_entry)
-          lookup(config_entry)
+        def has?(name, version)
+          lookup(name, version)
         end
 
-        def versions(config_entry)
-          REPO.gems[config_entry['name']].versions.keys.map(&:to_s)
+        def versions(name)
+          REPO.gems[name].versions.keys.map(&:to_s)
         end
 
-        def install(dest:, config_entry:, stdout:)
+        def install(dest:, name:, version:, stdout:)
           # Do nothing because stdlib RBS is available by default
-          name = config_entry['name']
-          version = config_entry['version'] or raise
-          from = lookup(config_entry)
+          from = lookup(name, version)
           stdout.puts "Using #{name}:#{version} (#{from})"
         end
 
-        def manifest_of(config_entry)
-          config_entry['version'] or raise
-          manifest_path = (lookup(config_entry) or raise).join('manifest.yaml')
+        def manifest_of(name, version)
+          manifest_path = (lookup(name, version) or raise).join('manifest.yaml')
           YAML.safe_load(manifest_path.read) if manifest_path.exist?
         end
 
@@ -40,8 +37,8 @@ module RBS
           }
         end
 
-        private def lookup(config_entry)
-          REPO.lookup(config_entry['name'], config_entry['version'])
+        private def lookup(name, version)
+          REPO.lookup(name, version)
         end
       end
     end

data/lib/rbs/collection/sources.rb

@@ -11,7 +11,13 @@ module RBS
       def self.from_config_entry(source_entry)
         case source_entry['type']
         when 'git', nil # git source by default
-          __skip__ = Git.new(**source_entry.slice('name', 'revision', 'remote', 'repo_dir').transform_keys(&:to_sym))
+          # @type var source_entry: Git::source_entry
+          Git.new(
+            name: source_entry["name"],
+            revision: source_entry["revision"],
+            remote: source_entry["remote"],
+            repo_dir: source_entry["repo_dir"]
+          )
         when 'stdlib'
           Stdlib.instance
         when 'rubygems'

data/lib/rbs/collection.rb

@@ -5,6 +5,7 @@ require 'bundler'
 
 require_relative './collection/sources'
 require_relative './collection/config'
+require_relative './collection/config/lockfile'
 require_relative './collection/config/lockfile_generator'
 require_relative './collection/installer'
 require_relative './collection/cleaner'

data/lib/rbs/definition.rb

@@ -65,7 +65,7 @@ module RBS
         def overload?
           case mem = member
           when AST::Members::MethodDefinition
-            mem.overload?
+            mem.overloading?
           else
             false
           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/method_builder.rb

@@ -113,14 +113,14 @@ module RBS
                       build_method(
                         methods,
                         type,
-                        member: member.update(types: member.types.map {|type| type.sub(subst) }),
+                        member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
                         accessibility: member.visibility || accessibility
                       )
                     when :singleton_instance
                       build_method(
                         methods,
                         type,
-                        member: member.update(types: member.types.map {|type| type.sub(subst) }),
+                        member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
                         accessibility: :private
                       )
                     end
@@ -215,7 +215,7 @@ module RBS
       def build_method(methods, type, member:, accessibility:)
         defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)
 
-        if member.overload?
+        if member.overloading?
           defn.overloads << member
         else
           defn.accessibilities << accessibility