rbs 3.0.0.dev.1 → 3.0.0.dev.3

data/lib/rbs/environment_loader.rb

@@ -47,8 +47,9 @@ module RBS
       when path
         dirs << path
       when library
-        if library == 'rubygems'
-          RBS.logger.warn '`rubygems` has been moved to core library, so it is always loaded. Remove explicit loading `rubygems`'
+        case library
+        when 'rubygems', 'set'
+          RBS.logger.warn "`#{library}` has been moved to core library, so it is always loaded. Remove explicit loading `#{library}`"
           return
         end
 
@@ -95,9 +96,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 +151,7 @@ module RBS
       end
     end
 
-    def each_decl
+    def each_signature
       files = Set[]
 
       each_dir do |source, dir|
@@ -160,9 +163,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

@@ -20,7 +20,25 @@ module RBS
   class LoadingError < BaseError; end
   class DefinitionError < BaseError; end
 
+  module DetailedMessageable
+    def detailed_message(highlight: false, **)
+      indent = " " * location.start_column
+      marker = "^" * (location.end_column - location.start_column)
+
+      io = StringIO.new
+      io.puts super
+      io.puts
+      io.print "\e[1m" if highlight
+      io.puts "  #{location.buffer.lines[location.end_line - 1]}"
+      io.puts "  #{indent}#{marker}"
+      io.print "\e[m" if highlight
+      io.string
+    end
+  end
+
   class ParsingError < BaseError
+    include DetailedMessageable
+
     attr_reader :location
     attr_reader :error_message
     attr_reader :token_type
@@ -119,19 +137,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 +154,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 +172,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 +192,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 +212,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 +404,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 +465,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

@@ -2,21 +2,24 @@
 
 module RBS
   class Locator
-    attr_reader :decls
+    attr_reader :decls, :dirs, :buffer
 
-    def initialize(decls:)
+    def initialize(buffer:, dirs:, decls:)
+      @buffer = buffer
+      @dirs = dirs
       @decls = decls
     end
 
-    def buffer
-      decls[0].location&.buffer or raise
-    end
-
     def find(line:, column:)
       pos = buffer.loc_to_pos([line, column])
 
+      dirs.each do |dir|
+        array = [] #: Array[component]
+        find_in_directive(pos, dir, array) and return array
+      end
+
       decls.each do |decl|
-        array = []
+        array = [] #: Array[component]
         find_in_decl(pos, decl: decl, array: array) and return array
       end
 
@@ -36,6 +39,22 @@ module RBS
       end
     end
 
+    def find_in_directive(pos, dir, array)
+      if test_loc(pos, location: dir.location)
+        array.unshift(dir)
+
+        dir.clauses.each do |clause|
+          if test_loc(pos, location: clause.location)
+            array.unshift(clause)
+            find_in_loc(pos, location: clause.location, array: array)
+            return true
+          end
+        end
+      end
+
+      false
+    end
+
     def find_in_decl(pos, decl:, array:)
       if test_loc(pos, location: decl.location)
         array.unshift(decl)
@@ -95,7 +114,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,11 +30,11 @@ module RBS
 
     def group(member)
       case member
-      when Declarations::Alias
+      when Declarations::TypeAlias
         -3
       when Declarations::Constant
         -2
-      when Declarations::Class, Declarations::Module
+      when Declarations::Class, Declarations::Module, Declarations::Interface
         -1
       when Members::Include
         0.0
@@ -100,9 +100,9 @@ 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
+      when Declarations::Class, Declarations::Module, Declarations::Interface
         member.name.to_s
       else
         raise

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.3"
 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