rbs 2.8.4 → 3.0.0.dev.2

data/lib/rbs/test/setup.rb

@@ -67,7 +67,7 @@ TracePoint.trace :end do |tp|
 
   if class_name
     if filter.any? {|f| match(to_absolute_typename(f).to_s, class_name.to_s) } && skips.none? {|f| match(f, class_name.to_s) }
-      if env.class_decls.key?(class_name)
+      if env.module_name?(class_name)
         logger.info "Setting up hooks for #{class_name}"
         tester.install!(tp.self, sample_size: sample_size, unchecked_classes: unchecked_classes)
       end

data/lib/rbs/type_alias_dependency.rb

@@ -32,7 +32,7 @@ module RBS
       # Initialize dependencies as an empty hash
       @dependencies = {}
       # Iterate over alias declarations inserted into environment
-      env.alias_decls.each do |name, entry|
+      env.type_alias_decls.each do |name, entry|
         # Construct a directed graph by recursively extracting type aliases
         @direct_dependencies[name] = direct_dependency(entry.decl.type)
         # Initialize dependencies with an empty hash

data/lib/rbs/type_alias_regularity.rb

@@ -57,7 +57,7 @@ module RBS
     end
 
     def build_alias_type(name)
-      entry = env.alias_decls[name] or return
+      entry = env.type_alias_decls[name] or return
       unless entry.decl.type_params.empty?
         as = entry.decl.type_params.each.map {|param| Types::Variable.new(name: param.name, location: nil) }
         Types::Alias.new(name: name, args: as, location: nil)
@@ -81,13 +81,13 @@ module RBS
     def each_mutual_alias_defs(&block)
       # @type var each_node: TSort::_EachNode[TypeName]
       each_node = __skip__ = -> (&block) do
-        env.alias_decls.each_value do |decl|
+        env.type_alias_decls.each_value do |decl|
           block[decl.name]
         end
       end
       # @type var each_child: TSort::_EachChild[TypeName]
       each_child = __skip__ = -> (name, &block) do
-        if env.alias_decls.key?(name)
+        if env.type_alias_decls.key?(name)
           type = builder.expand_alias1(name)
           each_alias_type(type) do |ty|
             block[ty.name]

data/lib/rbs/types.rb

@@ -757,11 +757,7 @@ module RBS
 
         def to_s
           if name
-            if Parser::KEYWORDS.include?(name.to_s)
-              "#{type} `#{name}`"
-            else
-              "#{type} #{name}"
-            end
+            "#{type} #{name}"
           else
             "#{type}"
           end

data/lib/rbs/validator.rb

@@ -33,11 +33,12 @@ module RBS
 
         type_params = case type
                       when Types::ClassInstance
-                        env.class_decls[type.name].type_params
+                        entry = env.normalized_module_class_entry(type.name) or raise
+                        entry.type_params
                       when Types::Interface
                         env.interface_decls[type.name].decl.type_params
                       when Types::Alias
-                        env.alias_decls[type.name].decl.type_params
+                        env.type_alias_decls[type.name].decl.type_params
                       end
 
         InvalidTypeApplicationError.check!(
@@ -98,7 +99,8 @@ module RBS
     end
 
     def validate_method_definition(method_def, type_name:)
-      method_def.types.each do |method_type|
+      method_def.overloads.each do |overload|
+        method_type = overload.method_type
         unless method_type.type_params.empty?
           loc = method_type.location&.aref(:type_params)
 
@@ -146,6 +148,26 @@ module RBS
       end
     end
 
+    def validate_class_alias(entry:)
+      case env.normalize_module_name?(entry.decl.new_name)
+      when nil
+        raise NoTypeFoundError.new(type_name: entry.decl.old_name, location: entry.decl.location&.[](:old_name))
+      when false
+        raise CyclicClassAliasDefinitionError.new(entry)
+      end
+
+      case entry
+      when Environment::ClassAliasEntry
+        unless env.class_entry(entry.decl.old_name)
+          raise InconsistentClassModuleAliasError.new(entry)
+        end
+      when Environment::ModuleAliasEntry
+        unless env.module_entry(entry.decl.old_name)
+          raise InconsistentClassModuleAliasError.new(entry)
+        end
+      end
+    end
+
     def type_alias_dependency
       @type_alias_dependency ||= TypeAliasDependency.new(env: env)
     end

data/lib/rbs/variance_calculator.rb

@@ -108,7 +108,7 @@ module RBS
     end
 
     def in_type_alias(name:)
-      decl = env.alias_decls[name].decl or raise
+      decl = env.type_alias_decls[name].decl or raise
       variables = decl.type_params.each.map(&:name)
       Result.new(variables: variables).tap do |result|
         type(decl.type, result: result, context: :covariant)
@@ -139,7 +139,7 @@ module RBS
                       when Types::Interface
                         env.interface_decls[type.name].decl.type_params
                       when Types::Alias
-                        env.alias_decls[type.name].decl.type_params
+                        env.type_alias_decls[type.name].decl.type_params
                       end
 
         type.args.each.with_index do |ty, i|

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "2.8.4"
+  VERSION = "3.0.0.dev.2"
 end

data/lib/rbs/writer.rb

@@ -39,21 +39,27 @@ module RBS
       end
     end
 
+    def format_annotation(annotation)
+      string = annotation.string
+      case
+      when string !~ /\}/
+        "%a{#{string}}"
+      when string !~ /\)/
+        "%a(#{string})"
+      when string !~ /\]/
+        "%a[#{string}]"
+      when string !~ /\>/
+        "%a<#{string}>"
+      when string !~ /\|/
+        "%a|#{string}|"
+      else
+        raise
+      end
+    end
+
     def write_annotation(annotations)
       annotations.each do |annotation|
-        string = annotation.string
-        case
-        when string !~ /\}/
-          puts "%a{#{string}}"
-        when string !~ /\)/
-          puts "%a(#{string})"
-        when string !~ /\]/
-          puts "%a[#{string}]"
-        when string !~ /\>/
-          puts "%a<#{string}>"
-        when string !~ /\|/
-          puts "%a|#{string}|"
-        end
+        puts format_annotation(annotation)
       end
     end
 
@@ -70,7 +76,16 @@ module RBS
       end
     end
 
-    def write(decls)
+    def write(contents)
+      dirs = contents.select {|c| c.is_a?(AST::Directives::Base) } #: Array[AST::Directives::t]
+      decls = contents.select {|c| c.is_a?(AST::Declarations::Base) } #: Array[AST::Declarations::t]
+
+      dirs.each do |dir|
+        write_directive(dir)
+      end
+
+      puts unless dirs.empty?
+
       [nil, *decls].each_cons(2) do |prev, decl|
         raise unless decl
 
@@ -79,6 +94,23 @@ module RBS
       end
     end
 
+    def write_directive(dir)
+      clauses = dir.clauses.map do |clause|
+        case clause
+        when AST::Directives::Use::SingleClause
+          if clause.new_name
+            "#{clause.type_name} as #{clause.new_name}"
+          else
+            "#{clause.type_name}"
+          end
+        when AST::Directives::Use::WildcardClause
+          "#{clause.namespace}*"
+        end
+      end
+      
+      puts "use #{clauses.join(", ")}"
+    end
+
     def write_decl(decl)
       case decl
       when AST::Declarations::Class
@@ -128,7 +160,7 @@ module RBS
         write_comment decl.comment
         puts "#{decl.name}: #{decl.type}"
 
-      when AST::Declarations::Alias
+      when AST::Declarations::TypeAlias
         write_comment decl.comment
         write_annotation decl.annotations
         write_loc_source(decl) {
@@ -289,17 +321,20 @@ module RBS
 
       string << prefix
 
-      member.types.each.with_index do |type, index|
+      member.overloads.each.with_index do |overload, index|
         if index > 0
           string << padding
           string << "|"
         end
 
-        string << " #{type}\n"
+        overload.annotations.each do |annotation|
+          string << " #{format_annotation(annotation)}"
+        end
+        string << " #{overload.method_type}\n"
       end
 
-      if member.overload
-        if member.types.size > 0
+      if member.overloading?
+        if member.overloads.size > 0
           string << padding
           string << "|"
         end

data/lib/rbs.rb

@@ -17,10 +17,12 @@ require "rbs/type_name"
 require "rbs/types"
 require "rbs/method_type"
 require "rbs/ast/type_param"
+require "rbs/ast/directives"
 require "rbs/ast/declarations"
 require "rbs/ast/members"
 require "rbs/ast/annotation"
 require "rbs/environment"
+require "rbs/environment/use_map"
 require "rbs/environment_loader"
 require "rbs/builtin_names"
 require "rbs/definition"
@@ -32,14 +34,13 @@ require "rbs/substitution"
 require "rbs/constant"
 require "rbs/resolver/constant_resolver"
 require "rbs/resolver/type_name_resolver"
-require "rbs/constant_table"
 require "rbs/ast/comment"
 require "rbs/writer"
 require "rbs/prototype/helpers"
 require "rbs/prototype/rbi"
 require "rbs/prototype/rb"
 require "rbs/prototype/runtime"
-require "rbs/type_name_resolver"
+require "rbs/prototype/node_usage"
 require "rbs/environment_walker"
 require "rbs/vendorer"
 require "rbs/validator"

data/lib/rdoc_plugin/parser.rb

@@ -14,8 +14,8 @@ module RBS
       end
 
       def scan
-        ast = ::RBS::Parser.parse_signature(@content)
-        ast.each do |decl|
+        _, _, decls = ::RBS::Parser.parse_signature(@content)
+        decls.each do |decl|
           parse_member(decl: decl, context: @top_level)
         end
         @top_level
@@ -74,7 +74,7 @@ module RBS
         method = RDoc::AnyMethod.new(nil, decl.name.to_s)
         method.singleton = decl.singleton?
         method.visibility = decl.visibility
-        method.call_seq = decl.types.map { |type| "#{decl.name.to_s}#{type.to_s}" }.join("\n")
+        method.call_seq = decl.overloads.map {|overload| "#{decl.name.to_s}#{overload.method_type.to_s}" }.join("\n")
         if loc = decl.location
           method.start_collecting_tokens
           method.add_token({ line_no: 1, char_no: 1, kind: :on_comment, text: "# File #{@top_level.relative_name}, line(s) #{loc.start_line}:#{loc.end_line}\n" })

data/schema/members.json

@@ -14,10 +14,21 @@
         "kind": {
           "enum": ["instance", "singleton", "singleton_instance"]
         },
-        "types": {
+        "overloads": {
           "type": "array",
           "items": {
-            "$ref": "methodType.json"
+            "type": "object",
+            "properties": {
+              "annotations": {
+                "type": "array",
+                "items": {
+                  "$ref": "annotation.json"
+                }
+              },
+              "method_type": {
+                "$ref": "methodType.json"
+              }
+            }
           }
         },
         "comment": {
@@ -29,23 +40,17 @@
             "$ref": "annotation.json"
           }
         },
-        "attributes": {
-          "type": "array",
-          "items": {
-            "enum": ["incompatible"]
-          }
-        },
         "location": {
           "$ref": "location.json"
         },
-        "overload": {
+        "overloading": {
           "type": "boolean"
         },
         "visibility": {
           "enum": ["public", "private", null]
         }
       },
-      "required": ["member", "name", "kind", "types", "comment", "annotations", "location", "visibility"]
+      "required": ["member", "name", "kind", "overloads", "comment", "annotations", "location", "visibility", "overloading"]
     },
     "variable": {
       "title": "Declaration for instance variables and class variables",

data/sig/ancestor_graph.rbs

@@ -1,4 +1,22 @@
 module RBS
+  # AncestorGraph is a utility class that helps iterating through ancestors and decendants of a class/module
+  #
+  # ```ruby
+  # graph = AncestorGraph.new(env: env, ancestor_builder: ancestor_builder)
+  #
+  # graph.each_parent(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
+  # graph.each_ancestor(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
+  #
+  # graph.each_child(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
+  # graph.each_descendant(AncestorGraph::InstanceNode.new(type_name: TypeName("::Object")))
+  # ```
+  #
+  # Note that the class works for class/module declarations.
+  # All of the *alias* classes/modules are ignored.
+  #
+  # * Alias classes/modules doesn't count as a parent nor child
+  # * Passing alias classes/modules to the method doesn't yield anything
+  #
   class AncestorGraph
     class InstanceNode
       attr_reader type_name: TypeName
@@ -19,8 +37,6 @@ module RBS
 
     def initialize: (env: Environment, ?ancestor_builder: DefinitionBuilder::AncestorBuilder) -> void
 
-    def build: () -> void
-
     def each_parent: (node) { (node) -> void } -> void
                    | (node) -> Enumerator[node, void]
 
@@ -33,6 +49,10 @@ module RBS
     def each_descendant: (node, ?yielded: Set[node]) { (node) -> void } -> void
                        | (node) -> Enumerator[node, void]
 
+    private
+
+    def build: () -> void
+
     def build_ancestors: (node, DefinitionBuilder::AncestorBuilder::OneAncestors) -> void
 
     def register: (parent: node, child: node) -> void

data/sig/collection/config/lockfile.rbs

@@ -0,0 +1,80 @@
+module RBS
+  module Collection
+    class Config
+      # Lockfile represents the `rbs_collection.lock.yaml`, that contains configurations and *resolved* gems with their sources
+      #
+      class Lockfile
+        # Data structure stored in `rbs_collection.lock.yaml`
+        #
+        type lockfile_data = {
+          "sources" => Array[Sources::Git::source_entry]?,   # null if empty
+          "path" => String,
+          "gems" => Array[library_data]?,         # null if empty
+          "gemfile_lock_path" => String?          # gemfile_lock_path is optional because older versions doesn't have it
+        }
+
+        type library_data = {
+          'name' => String,
+          'version' => String,
+          'source' => Sources::source_entry
+        }
+
+        # In-memory data structure that represents a library
+        #
+        type library = {
+          name: String,
+          version: String,
+          source: Sources::t
+        }
+
+        attr_reader lockfile_path: Pathname
+
+        # Path of the directory where lockfile is saved in
+        #
+        # `lockfile_path.parent`
+        #
+        attr_reader lockfile_dir: Pathname
+
+        # Relative to lockfile_dir
+        #
+        attr_reader path: Pathname
+
+        # Relative to lockfile_dir
+        #
+        attr_reader gemfile_lock_path: Pathname?
+
+        attr_reader sources: Hash[String, Sources::Git]
+
+        attr_reader gems: Hash[String, library]
+
+        def initialize: (lockfile_path: Pathname, path: Pathname, gemfile_lock_path: Pathname?) -> void
+
+        # `lockfile_dir` + `path`
+        #
+        def fullpath: () -> Pathname
+
+        # `lockfile_dir` + `gemfile_lock_path`
+        #
+        %a{pure} def gemfile_lock_fullpath: () -> Pathname?
+
+        def to_lockfile: () -> lockfile_data
+
+        def each_source: () { (Sources::t) -> void } -> void
+                       | () -> Enumerator[Sources::t, void]
+
+        def self.from_lockfile: (lockfile_path: Pathname, data: lockfile_data) -> Lockfile
+
+        # Validates if directories are set up correctly
+        #
+        # * Ensures if `path` is a directory
+        # * Ensures if `git` sources are set up correctly
+        #
+        def check_rbs_availability!: () -> void
+
+        private
+
+        def library_data: (library) -> library_data
+      end
+    end
+  end
+end

data/sig/collection/config/lockfile_generator.rbs

@@ -0,0 +1,53 @@
+module RBS
+  module Collection
+    class Config
+      class LockfileGenerator
+        class GemfileLockMismatchError < StandardError
+          @expected: Pathname
+
+          @actual: Pathname
+
+          def initialize: (expected: Pathname, actual: Pathname) -> void
+
+          def message: () -> String
+        end
+
+        attr_reader config: Config
+
+        attr_reader lockfile: Lockfile
+        attr_reader existing_lockfile: Lockfile?
+
+        attr_reader definition: Bundler::Definition
+
+        # A hash table to look up a spec from name of the gem
+        attr_reader gem_hash: Hash[String, Bundler::LazySpecification]
+
+        def self.generate: (config: Config, definition: Bundler::Definition, ?with_lockfile: boolish) -> Lockfile
+
+        def initialize: (config: Config, definition: Bundler::Definition, with_lockfile: boolish) -> void
+
+        def generate: () -> void
+
+        private
+
+        # Ensure if current `gemfile_lock_path` is the same with the path saved in `lock`
+        #
+        def validate_gemfile_lock_path!: (lock: Lockfile?, gemfile_lock_path: Pathname) -> void
+
+        # Inserts a entry to lockfile of a gem and its dependencies, if not included in `ignored_gems:`
+        #
+        def assign_gem: (name: String, version: String?, src_data: Sources::source_entry?, ignored_gems: Set[String]) -> void
+
+        def assign_stdlib: (name: String, from_gem: String?) -> void
+
+        # Find a source of a gem from ones registered in `config.sources`
+        #
+        # Returns `nil` if no source contains the definition of the gem.
+        #
+        def find_source: (name: String) -> Sources::t?
+
+        def find_best_version: (version: String?, versions: Array[String]) -> Gem::Version
+      end
+    end
+  end
+end

data/sig/collection/config.rbs

@@ -6,39 +6,6 @@ module RBS
         def initialize: () -> void
       end
 
-      class LockfileGenerator
-        attr_reader config: Config
-        attr_reader lock: Config?
-        attr_reader lock_path: Pathname
-        attr_reader gemfile_lock: Bundler::LockfileParser
-
-        type gem_queue_entry = { name: String, version: String? }
-
-        @gem_queue: Array[gem_queue_entry]
-
-        def self.generate: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Config
-
-        def initialize: (config_path: Pathname, gemfile_lock_path: Pathname, with_lockfile: boolish) -> void
-
-        def generate: () -> Config
-
-        private
-
-        def validate_gemfile_lock_path!: (lock: Config?, gemfile_lock_path: Pathname) -> void
-
-        def assign_gem: (name: String, version: String?) -> void
-
-        def upsert_gem: (gem_entry? old, gem_entry new) -> void
-
-        def gemfile_lock_gems: () { (untyped) -> void } -> void
-
-        def remove_ignored_gems!: () -> void
-
-        def find_source: (name: String) -> Sources::_Source?
-
-        def find_best_version: (version: String?, versions: Array[String]) -> Gem::Version
-      end
-
       PATH: Pathname
 
       type gem_entry = {
@@ -48,42 +15,32 @@ module RBS
         'source' => Sources::source_entry?
       }
 
-      @config_path: Pathname
+      attr_reader config_path: Pathname
 
-      @data: untyped
+      attr_reader data: untyped
 
       @sources: Array[Sources::_Source]
 
       def self.find_config_path: () -> Pathname?
 
-      def self.generate_lockfile: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Config
+      def self.generate_lockfile: (config_path: Pathname, definition: Bundler::Definition, ?with_lockfile: boolish) -> [Config, Lockfile]
 
       def self.from_path: (Pathname path) -> Config
 
-      def self.lockfile_of: (Pathname config_path) -> Config?
-
       def self.to_lockfile_path: (Pathname config_path) -> Pathname
 
       # config_path is necessary to resolve relative repo_path
       def initialize: (untyped data, config_path: Pathname) -> void
 
-      def add_gem: (gem_entry gem) -> void
-
       def gem: (String gem_name) -> gem_entry?
 
       def repo_path: () -> Pathname
 
-      def sources: () -> Array[Sources::_Source]
+      def repo_path_data: () -> Pathname
 
-      def dump_to: (Pathname) -> void
+      def sources: () -> Array[Sources::t]
 
       def gems: () -> Array[gem_entry]
-
-      def gemfile_lock_path=: (Pathname) -> Pathname
-
-      def gemfile_lock_path: () -> Pathname?
-
-      def check_rbs_availability!: () -> void
     end
   end
 end

data/sig/collection/installer.rbs

@@ -1,7 +1,7 @@
 module RBS
   module Collection
     class Installer
-      attr_reader lockfile: Config
+      attr_reader lockfile: Config::Lockfile
       attr_reader stdout: CLI::_IO
 
       def initialize: (lockfile_path: Pathname, ?stdout: CLI::_IO) -> void