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

data/lib/rbs/environment_loader.rb

@@ -95,9 +95,11 @@ module RBS
       # @type var loaded: Array[[AST::Declarations::t, Pathname, source]]
       loaded = []
 
-      each_decl do |decl, buf, source, path|
-        env << decl
-        loaded << [decl, path, source]
+      each_signature do |source, path, buffer, decls, dirs|
+        decls.each do |decl|
+          loaded << [decl, path, source]
+        end
+        env.add_signature(buffer: buffer, directives: dirs, decls: decls)
       end
 
       loaded
@@ -148,7 +150,7 @@ module RBS
       end
     end
 
-    def each_decl
+    def each_signature
       files = Set[]
 
       each_dir do |source, dir|
@@ -160,9 +162,9 @@ module RBS
           files << path
           buffer = Buffer.new(name: path.to_s, content: path.read(encoding: "UTF-8"))
 
-          Parser.parse_signature(buffer).each do |decl|
-            yield decl, buffer, source, path
-          end
+          _, dirs, decls = Parser.parse_signature(buffer)
+
+          yield source, path, buffer, decls, dirs
         end
       end
     end

data/lib/rbs/environment_walker.rb

@@ -36,7 +36,7 @@ module RBS
       env.interface_decls.each_key do |type_name|
         yield TypeNameNode.new(type_name: type_name)
       end
-      env.alias_decls.each_key do |type_name|
+      env.type_alias_decls.each_key do |type_name|
         yield TypeNameNode.new(type_name: type_name)
       end
     end

data/lib/rbs/errors.rb

@@ -119,19 +119,7 @@ module RBS
     end
 
     def self.check!(type_name, env:, location:)
-      dic = case
-            when type_name.class?
-              env.class_decls
-            when type_name.alias?
-              env.alias_decls
-            when type_name.interface?
-              env.interface_decls
-            else
-              raise
-            end
-
-      dic.key?(type_name) or raise new(type_name: type_name, location: location)
-
+      env.type_name?(type_name) or raise new(type_name: type_name, location: location)
       type_name
     end
   end
@@ -148,7 +136,7 @@ module RBS
     end
 
     def self.check!(type_name, env:, location:)
-      if decl = env.class_decls[type_name]
+      if env.module_name?(type_name)
         return
       end
 
@@ -166,7 +154,7 @@ module RBS
     end
 
     def self.check!(super_decl, env:)
-      return if env.class_decls[super_decl.name].is_a?(Environment::ClassEntry)
+      return if env.class_decl?(super_decl.name) || env.class_alias?(super_decl.name)
 
       raise new(super_decl)
     end
@@ -186,16 +174,7 @@ module RBS
     def self.check!(self_type, env:)
       type_name = self_type.name
 
-      dic = case
-            when type_name.class?
-              env.class_decls
-            when type_name.interface?
-              env.interface_decls
-            else
-              raise
-            end
-
-      dic.key?(type_name) or raise new(type_name: type_name, location: self_type.location)
+      (env.module_name?(type_name) || env.interface_name?(type_name)) or raise new(type_name: type_name, location: self_type.location)
     end
   end
 
@@ -215,16 +194,7 @@ module RBS
     end
 
     def self.check!(type_name, env:, member:)
-      dic = case
-            when type_name.class?
-              env.class_decls
-            when type_name.interface?
-              env.interface_decls
-            else
-              raise
-            end
-
-      dic.key?(type_name) or raise new(type_name: type_name, member: member)
+      (env.module_name?(type_name) || env.interface_name?(type_name)) or raise new(type_name: type_name, member: member)
     end
   end
 
@@ -416,8 +386,7 @@ module RBS
     end
 
     def self.check!(type_name:, env:, member:)
-      case env.class_decls[member.name]
-      when Environment::ClassEntry
+      if env.class_decl?(member.name)
         raise new(type_name: type_name, member: member)
       end
     end
@@ -478,4 +447,32 @@ module RBS
       super "#{Location.to_string(location)}: Cyclic type parameter bound is prohibited"
     end
   end
+
+  class InconsistentClassModuleAliasError < BaseError
+    attr_reader :alias_entry
+
+    def initialize(entry)
+      @alias_entry = entry
+
+      expected_kind, actual_kind =
+        case entry
+        when Environment::ModuleAliasEntry
+          ["module", "class"]
+        when Environment::ClassAliasEntry
+          ["class", "module"]
+        end
+
+      super "#{Location.to_string(entry.decl.location&.[](:old_name))}: A #{expected_kind} `#{entry.decl.new_name}` cannot be an alias of a #{actual_kind} `#{entry.decl.old_name}`"
+    end
+  end
+
+  class CyclicClassAliasDefinitionError < BaseError
+    attr_reader :alias_entry
+
+    def initialize(entry)
+      @alias_entry = entry
+
+      super "#{Location.to_string(entry.decl.location&.[](:old_name))}: A #{alias_entry.decl.new_name} is a cyclic definition"
+    end
+  end
 end

data/lib/rbs/locator.rb

@@ -95,7 +95,7 @@ module RBS
         when AST::Declarations::Constant, AST::Declarations::Global
           find_in_type(pos, array: array, type: decl.type) and return true
 
-        when AST::Declarations::Alias
+        when AST::Declarations::TypeAlias
           find_in_type(pos, array: array, type: decl.type) and return true
         end
 

data/lib/rbs/parser_aux.rb

@@ -2,19 +2,21 @@
 
 module RBS
   class Parser
-    def self.parse_type(source, line: nil, column: nil, range: nil, variables: [])
+    def self.parse_type(source, range: 0..., variables: [])
       buf = buffer(source)
-      _parse_type(buf, range&.begin || 0, range&.end || buf.last_position, variables, range.nil?)
+      _parse_type(buf, range.begin || 0, range.end || buf.last_position, variables)
     end
 
-    def self.parse_method_type(source, line: nil, column: nil, range: nil, variables: [])
+    def self.parse_method_type(source, range: 0..., variables: [])
       buf = buffer(source)
-      _parse_method_type(buf, range&.begin || 0, range&.end || buf.last_position, variables, range.nil?)
+      _parse_method_type(buf, range.begin || 0, range.end || buf.last_position, variables)
     end
 
-    def self.parse_signature(source, line: nil, column: nil)
+    def self.parse_signature(source)
       buf = buffer(source)
-      _parse_signature(buf, buf.last_position)
+      dirs, decls = _parse_signature(buf, buf.last_position)
+
+      [buf, dirs, decls]
     end
 
     def self.buffer(source)

data/lib/rbs/resolver/constant_resolver.rb

@@ -18,20 +18,33 @@ module RBS
           end
 
           environment.class_decls.each do |name, entry|
+            constant = constant_of_module(name, entry)
+
             unless name.namespace.empty?
               parent = name.namespace.to_type_name
-
               table = children_table[parent] or raise
-              constant = constant_of_module(name, entry)
             else
               table = toplevel
-              constant = constant_of_module(name, entry)
             end
 
             table[name.name] = constant
             constants_table[name] = constant
           end
 
+          environment.class_alias_decls.each do |name, entry|
+            normalized_entry = environment.normalized_module_class_entry(name) or next
+            constant = constant_of_module(name, normalized_entry)
+
+            # Insert class/module aliases into `children_table` and `toplevel` table
+            unless name.namespace.empty?
+              normalized_parent = environment.normalize_module_name?(name.namespace.to_type_name) or raise
+              table = children_table[normalized_parent] or raise
+              table[name.name] = constant
+            else
+              toplevel[name.name] = constant
+            end
+          end
+
           environment.constant_decls.each do |name, entry|
             unless name.namespace.empty?
               parent = name.namespace.to_type_name
@@ -97,6 +110,8 @@ module RBS
       end
 
       def children(module_name)
+        module_name = builder.env.normalize_module_name(module_name)
+
         unless child_constants_cache.key?(module_name)
           load_child_constants(module_name)
         end
@@ -113,6 +128,7 @@ module RBS
         else
           constants_from_ancestors(BuiltinNames::Object.name, constants: consts)
         end
+
         constants_from_context(context, constants: consts) or return
         constants_itself(context, constants: consts)
 
@@ -151,7 +167,7 @@ module RBS
           constants_from_context(parent, constants: constants) or return false
 
           if last
-            consts = table.children(last) or return false
+            consts = table.children(builder.env.normalize_module_name(last)) or return false
             constants.merge!(consts)
           end
         end
@@ -160,14 +176,14 @@ module RBS
       end
 
       def constants_from_ancestors(module_name, constants:)
-        entry = builder.env.class_decls[module_name]
+        entry = builder.env.normalized_module_class_entry(module_name) or raise
 
-        if entry.is_a?(Environment::ModuleEntry)
+        if entry.is_a?(Environment::ClassEntry) || entry.is_a?(Environment::ModuleEntry)
           constants.merge!(table.children(BuiltinNames::Object.name) || raise)
           constants.merge!(table.toplevel)
         end
 
-        builder.ancestor_builder.instance_ancestors(module_name).ancestors.reverse_each do |ancestor|
+        builder.ancestor_builder.instance_ancestors(entry.name).ancestors.reverse_each do |ancestor|
           if ancestor.is_a?(Definition::Ancestor::Instance)
             case ancestor.source
             when AST::Members::Include, :super, nil

data/lib/rbs/resolver/type_name_resolver.rb

@@ -12,7 +12,8 @@ module RBS
 
         all_names.merge(env.class_decls.keys)
         all_names.merge(env.interface_decls.keys)
-        all_names.merge(env.alias_decls.keys)
+        all_names.merge(env.type_alias_decls.keys)
+        all_names.merge(env.class_alias_decls.keys)
       end
 
       def try_cache(query)

data/lib/rbs/sorter.rb

@@ -15,7 +15,7 @@ module RBS
       stdout.puts "Opening #{path}..."
 
       buffer = Buffer.new(name: path, content: path.read)
-      sigs = Parser.parse_signature(buffer)
+      _, _, sigs = Parser.parse_signature(buffer)
 
       sigs.each do |m|
         sort_decl! m
@@ -30,7 +30,7 @@ module RBS
 
     def group(member)
       case member
-      when Declarations::Alias
+      when Declarations::TypeAlias
         -3
       when Declarations::Constant
         -2
@@ -100,7 +100,7 @@ module RBS
         member.new_name.to_s
       when Declarations::Constant
         member.name.to_s
-      when Declarations::Alias
+      when Declarations::TypeAlias
         member.name.to_s
       when Declarations::Class, Declarations::Module
         member.name.to_s

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/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!(
@@ -147,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 = "3.0.0.dev.1"
+  VERSION = "3.0.0.dev.2"
 end

data/lib/rbs/writer.rb

@@ -76,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
 
@@ -85,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
@@ -134,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) {

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,7 +34,6 @@ 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"
@@ -40,7 +41,6 @@ require "rbs/prototype/rbi"
 require "rbs/prototype/rb"
 require "rbs/prototype/runtime"
 require "rbs/prototype/node_usage"
-require "rbs/type_name_resolver"
 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

data/rbs.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin|steep)/}) }
   end
   spec.extensions = %w{ext/rbs_extension/extconf.rb}
 

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_generator.rbs

@@ -13,18 +13,18 @@ module RBS
         end
 
         attr_reader config: Config
-        attr_reader gemfile_lock: Bundler::LockfileParser
 
         attr_reader lockfile: Lockfile
         attr_reader existing_lockfile: Lockfile?
 
-        type gem_queue_entry = { name: String, version: String? }
+        attr_reader definition: Bundler::Definition
 
-        @gem_queue: Array[gem_queue_entry]
+        # 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, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Lockfile
+        def self.generate: (config: Config, definition: Bundler::Definition, ?with_lockfile: boolish) -> Lockfile
 
-        def initialize: (config: Config, gemfile_lock_path: Pathname, with_lockfile: boolish) -> void
+        def initialize: (config: Config, definition: Bundler::Definition, with_lockfile: boolish) -> void
 
         def generate: () -> void
 
@@ -34,14 +34,12 @@ module RBS
         #
         def validate_gemfile_lock_path!: (lock: Lockfile?, gemfile_lock_path: Pathname) -> void
 
-        def assign_gem: (name: String, version: String?, ignored_gems: Set[String], src_data: Sources::source_entry?) -> 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
 
-        def gemfile_lock_gems: () { (untyped) -> void } -> void
-
-        def remove_ignored_gems!: () -> void
-
         # Find a source of a gem from ones registered in `config.sources`
         #
         # Returns `nil` if no source contains the definition of the gem.

data/sig/collection/config.rbs

@@ -23,7 +23,7 @@ module RBS
 
       def self.find_config_path: () -> Pathname?
 
-      def self.generate_lockfile: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> [Config, Lockfile]
+      def self.generate_lockfile: (config_path: Pathname, definition: Bundler::Definition, ?with_lockfile: boolish) -> [Config, Lockfile]
 
       def self.from_path: (Pathname path) -> Config
 

data/sig/collection/sources.rbs

@@ -78,28 +78,34 @@ module RBS
 
         def cp_r: (Pathname, Pathname) -> void
 
-        # Ensure the git repository status is expected one
+        # Ensure the git repository exists, and
         #
-        # * It exists, and
-        # * The `HEAD` is the `revision`
+        # * When `revision` is a commit hash, the commit exists in the local repository, or
+        # * When `revision` is a branch name, the latest version is fetched from `origin`
+        #
+        # It may require a network connection to fetch or clone the repository from remote.
+        #
+        # * If `revision` is a commit hash and the commit doesn't exists in the local repository, it runs `git fetch`
+        # * If `revision` is a branch name, it runs `git fetch` once per instance
         #
         def setup!: [T] () { () -> T } -> T
                   | () -> void
 
         def need_to_fetch?: (String revision) -> bool
 
+        # The full path of local git repository
         def git_dir: () -> Pathname
 
+        # The full path of `repo_dir` in the local git repository
         def gem_repo_dir: () -> Pathname
 
-        def with_revision: [T] () { () -> T } -> T
-
         # Returns `true` if `revision` looks like a commit hash
-        #
         def commit_hash?: () -> bool
 
+        # Executes a git command, raises an error if failed
         def git: (*String cmd, **untyped opt) -> String
 
+        # Executes a git command, returns `nil` if failed
         def git?: (*String cmd, **untyped opt) -> String?
 
         def sh!: (*String cmd, **untyped opt) -> String