rbs 2.8.4 → 3.0.0.dev.2

data/ext/rbs_extension/ruby_objs.h

@@ -7,7 +7,7 @@ VALUE rbs_alias(VALUE typename, VALUE args, VALUE location);
 VALUE rbs_ast_annotation(VALUE string, VALUE location);
 VALUE rbs_ast_comment(VALUE string, VALUE location);
 VALUE rbs_ast_type_param(VALUE name, VALUE variance, bool unchecked, VALUE upper_bound, VALUE location);
-VALUE rbs_ast_decl_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_type_alias(VALUE name, VALUE type_params, VALUE type, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_class_super(VALUE name, VALUE args, VALUE location);
 VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE members, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment);
@@ -15,9 +15,12 @@ VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment)
 VALUE rbs_ast_decl_interface(VALUE name, VALUE type_params, VALUE members, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_decl_module_self(VALUE name, VALUE args, VALUE location);
 VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_module_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_class_alias(VALUE new_name, VALUE old_name, VALUE location, VALUE comment);
 VALUE rbs_ast_members_alias(VALUE new_name, VALUE old_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment, VALUE visibility);
-VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VALUE annotations, VALUE location, VALUE comment, VALUE overload, VALUE visibility);
+VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE overloads, VALUE annotations, VALUE location, VALUE comment, VALUE overloading, VALUE visibility);
+VALUE rbs_ast_members_method_definition_overload(VALUE annotations, VALUE method_type);
 VALUE rbs_ast_members_mixin(VALUE klass, VALUE name, VALUE args, VALUE annotations, VALUE location, VALUE comment);
 VALUE rbs_ast_members_variable(VALUE klass, VALUE name, VALUE type, VALUE location, VALUE comment);
 VALUE rbs_ast_members_visibility(VALUE klass, VALUE location);
@@ -40,4 +43,8 @@ VALUE rbs_type_name(VALUE namespace, VALUE name);
 VALUE rbs_union(VALUE types, VALUE location);
 VALUE rbs_variable(VALUE name, VALUE location);
 
+VALUE rbs_ast_directives_use(VALUE clauses, VALUE location);
+VALUE rbs_ast_directives_use_single_clause(VALUE type_name, VALUE new_name, VALUE location);
+VALUE rbs_ast_directives_use_wildcard_clause(VALUE namespace, VALUE location);
+
 #endif

data/lib/rbs/annotate/rdoc_annotator.rb

@@ -16,7 +16,7 @@ module RBS
       def annotate_file(path, preserve:)
         content = path.read()
 
-        decls = Parser.parse_signature(content)
+        _, _, decls = Parser.parse_signature(content)
 
         annotate_decls(decls)
 

data/lib/rbs/ast/declarations.rb

@@ -265,7 +265,7 @@ module RBS
         end
       end
 
-      class Alias < Base
+      class TypeAlias < Base
         attr_reader :name
         attr_reader :type_params
         attr_reader :type
@@ -283,7 +283,7 @@ module RBS
         end
 
         def ==(other)
-          other.is_a?(Alias) &&
+          other.is_a?(TypeAlias) &&
             other.name == name &&
             other.type_params == type_params &&
             other.type == type
@@ -379,6 +379,53 @@ module RBS
           }.to_json(state)
         end
       end
+
+      class AliasDecl < Base
+        attr_reader :new_name, :old_name, :location, :comment
+
+        def initialize(new_name:, old_name:, location:, comment:)
+          @new_name = new_name
+          @old_name = old_name
+          @location = location
+          @comment = comment
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.new_name == new_name &&
+            other.old_name == old_name
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ new_name.hash ^ old_name.hash
+        end
+      end
+
+      class ClassAlias < AliasDecl
+        def to_json(state = _ = nil)
+          {
+            declaration: :class_alias,
+            new_name: new_name,
+            old_name: old_name,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
+
+      class ModuleAlias < AliasDecl
+        def to_json(state = _ = nil)
+          {
+            declaration: :module_alias,
+            new_name: new_name,
+            old_name: old_name,
+            location: location,
+            comment: comment
+          }.to_json(state)
+        end
+      end
     end
   end
 end

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/ast/members.rb

@@ -7,23 +7,57 @@ module RBS
       end
 
       class MethodDefinition < Base
+        class Overload
+          attr_reader :method_type, :annotations
+
+          def initialize(method_type:, annotations:)
+            @method_type = method_type
+            @annotations = annotations
+          end
+
+          def ==(other)
+            other.is_a?(Overload) && other.method_type == method_type && other.annotations == annotations
+          end
+
+          def hash
+            method_type.hash ^ annotations.hash
+          end
+
+          alias eql? ==
+
+          def update(annotations: self.annotations, method_type: self.method_type)
+            Overload.new(annotations: annotations, method_type: method_type)
+          end
+
+          def sub(subst)
+            update(method_type: self.method_type.sub(subst))
+          end
+
+          def to_json(state = _ = nil)
+            {
+              annotations: annotations,
+              method_type: method_type
+            }.to_json(state)
+          end
+        end
+
         attr_reader :name
         attr_reader :kind
-        attr_reader :types
+        attr_reader :overloads
         attr_reader :annotations
         attr_reader :location
         attr_reader :comment
-        attr_reader :overload
+        attr_reader :overloading
         attr_reader :visibility
 
-        def initialize(name:, kind:, types:, annotations:, location:, comment:, overload:, visibility: nil)
+        def initialize(name:, kind:, overloads:, annotations:, location:, comment:, overloading:, visibility:)
           @name = name
           @kind = kind
-          @types = types
+          @overloads = overloads
           @annotations = annotations
           @location = location
           @comment = comment
-          @overload = overload ? true : false
+          @overloading = overloading
           @visibility = visibility
         end
 
@@ -31,15 +65,15 @@ module RBS
           other.is_a?(MethodDefinition) &&
             other.name == name &&
             other.kind == kind &&
-            other.types == types &&
-            other.overload == overload &&
+            other.overloads == overloads &&
+            other.overloading? == overloading? &&
             other.visibility == visibility
         end
 
         alias eql? ==
 
         def hash
-          name.hash ^ kind.hash ^ types.hash ^ overload.hash
+          name.hash ^ kind.hash ^ overloads.hash ^ overloading?.hash ^ visibility.hash
         end
 
         def instance?
@@ -50,19 +84,19 @@ module RBS
           kind == :singleton || kind == :singleton_instance
         end
 
-        def overload?
-          overload
+        def overloading?
+          overloading
         end
 
-        def update(name: self.name, kind: self.kind, types: self.types, annotations: self.annotations, location: self.location, comment: self.comment, overload: self.overload, visibility: self.visibility)
+        def update(name: self.name, kind: self.kind, overloads: self.overloads, annotations: self.annotations, location: self.location, comment: self.comment, overloading: self.overloading?, visibility: self.visibility)
           self.class.new(
             name: name,
             kind: kind,
-            types: types,
+            overloads: overloads,
             annotations: annotations,
             location: location,
             comment: comment,
-            overload: overload,
+            overloading: overloading,
             visibility: visibility
           )
         end
@@ -72,11 +106,11 @@ module RBS
             member: :method_definition,
             name: name,
             kind: kind,
-            types: types,
+            overloads: overloads,
             annotations: annotations,
             location: location,
             comment: comment,
-            overload: overload,
+            overloading: overloading?,
             visibility: visibility
           }.to_json(state)
         end

data/lib/rbs/cli.rb

@@ -29,7 +29,12 @@ module RBS
         end
 
         loader = EnvironmentLoader.new(core_root: core_root, repository: repository)
-        lock = config_path&.then { |p| Collection::Config.lockfile_of(p) }
+        if config_path
+          lock_path = Collection::Config.to_lockfile_path(config_path)
+          if lock_path.file?
+            lock = Collection::Config::Lockfile.from_lockfile(lockfile_path: lock_path, data: YAML.load_file(lock_path.to_s))
+          end
+        end
         loader.add_collection(lock) if lock
 
         dirs.each do |dir|
@@ -433,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
@@ -462,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(
@@ -490,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
@@ -532,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)
+
+      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}"
 
-      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}"
+      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}"
@@ -1038,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.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+    class Config
+      class Lockfile
+        attr_reader :lockfile_path, :lockfile_dir, :path, :gemfile_lock_path, :sources, :gems
+
+        def initialize(lockfile_path:, path:, gemfile_lock_path:)
+          @lockfile_path = lockfile_path
+          @lockfile_dir = lockfile_path.parent
+          @path = path
+          @gemfile_lock_path = gemfile_lock_path
+
+          @sources = {}
+          @gems = {}
+        end
+
+        def fullpath
+          lockfile_dir + path
+        end
+
+        def gemfile_lock_fullpath
+          if gemfile_lock_path
+            lockfile_dir + gemfile_lock_path
+          end
+        end
+
+        def each_source(&block)
+          if block
+            sources.each_value(&block)
+            yield Sources::Rubygems.instance
+            yield Sources::Stdlib.instance
+          else
+            enum_for :each_source
+          end
+        end
+
+        def to_lockfile
+          # @type var data: lockfile_data
+
+          data = {
+            "sources" => sources.each_value.sort_by {|s| s.name }.map {|source| source.to_lockfile },
+            "path" => path.to_s,
+            "gems" => gems.each_value.sort_by {|g| g[:name] }.map {|hash| library_data(hash) },
+            "gemfile_lock_path" => gemfile_lock_path.to_s
+          }
+
+          data.delete("sources") if sources.empty?
+          data.delete("gems") if gems.empty?
+
+          data
+        end
+
+        def self.from_lockfile(lockfile_path:, data:)
+          path = Pathname(data["path"])
+          if p = data["gemfile_lock_path"]
+            gemfile_lock_path = Pathname(p)
+          end
+
+          lockfile = Lockfile.new(lockfile_path: lockfile_path, path: path, gemfile_lock_path: gemfile_lock_path)
+
+          if sources = data["sources"]
+            sources.each do |src|
+              git = Sources::Git.new(
+                name: src["name"],
+                revision: src["revision"],
+                remote: src["remote"],
+                repo_dir: src["repo_dir"]
+              )
+              lockfile.sources[git.name] = git
+            end
+          end
+
+          if gems = data["gems"]
+            gems.each do |gem|
+              src = gem["source"]
+              source = Sources.from_config_entry(src)
+              lockfile.gems[gem["name"]] = {
+                name: gem["name"],
+                version: gem["version"],
+                source: source
+              }
+            end
+          end
+
+          lockfile
+        end
+
+        def library_data(lib)
+          {
+            "name" => lib[:name],
+            "version" => lib[:version],
+            "source" => lib[:source].to_lockfile
+          }
+        end
+
+        def check_rbs_availability!
+          raise CollectionNotAvailable unless fullpath.exist?
+
+          gems.each_value do |gem|
+            source = gem[:source]
+
+            case source
+            when Sources::Git
+              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)
+            end
+          end
+        end
+      end
+    end
+  end
+end