rbs 3.0.4 → 3.1.0

data/lib/rbs/errors.rb

@@ -22,11 +22,16 @@ module RBS
 
   module DetailedMessageable
     def detailed_message(highlight: false, **)
+      msg = super
+
+      # Support only one line
+      return msg unless location.start_line == location.end_line
+
       indent = " " * location.start_column
       marker = "^" * (location.end_column - location.start_column)
 
       io = StringIO.new
-      io.puts super
+      io.puts msg
       io.puts
       io.print "\e[1m" if highlight
       io.puts "  #{location.buffer.lines[location.end_line - 1]}"
@@ -125,7 +130,9 @@ module RBS
     end
   end
 
-  class NoTypeFoundError < BaseError
+  class NoTypeFoundError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type_name
     attr_reader :location
 
@@ -163,6 +170,8 @@ module RBS
   end
 
   class InheritModuleError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :super_decl
 
     def initialize(super_decl)
@@ -171,6 +180,10 @@ module RBS
       super "#{Location.to_string(super_decl.location)}: Cannot inherit a module: #{super_decl.name}"
     end
 
+    def location
+      @super_decl.location
+    end
+
     def self.check!(super_decl, env:)
       return if env.class_decl?(super_decl.name) || env.class_alias?(super_decl.name)
 
@@ -179,6 +192,8 @@ module RBS
   end
 
   class NoSelfTypeFoundError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type_name
     attr_reader :location
 
@@ -197,6 +212,8 @@ module RBS
   end
 
   class NoMixinFoundError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type_name
     attr_reader :member
 
@@ -217,6 +234,8 @@ module RBS
   end
 
   class DuplicatedMethodDefinitionError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type
     attr_reader :method_name
     attr_reader :members
@@ -256,6 +275,8 @@ module RBS
   end
 
   class DuplicatedInterfaceMethodDefinitionError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type
     attr_reader :method_name
     attr_reader :member
@@ -268,6 +289,10 @@ module RBS
       super "#{member.location}: Duplicated method definition: #{qualified_method_name}"
     end
 
+    def location
+      member.location
+    end
+
     def qualified_method_name
       case type
       when Types::ClassSingleton
@@ -283,6 +308,8 @@ module RBS
   end
 
   class UnknownMethodAliasError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type_name
     attr_reader :original_name
     attr_reader :aliased_name
@@ -310,6 +337,8 @@ module RBS
   end
 
   class InvalidOverloadMethodError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type_name
     attr_reader :method_name
     attr_reader :kind
@@ -330,6 +359,10 @@ module RBS
 
       super "#{Location.to_string members[0].location}: Invalid method overloading: #{type_name}#{delimiter}#{method_name}"
     end
+
+    def location
+      members[0].location
+    end
   end
 
   class GenericParameterMismatchError < LoadingError
@@ -357,6 +390,8 @@ module RBS
   end
 
   class InvalidVarianceAnnotationError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type_name
     attr_reader :param
     attr_reader :location
@@ -371,6 +406,8 @@ module RBS
   end
 
   class RecursiveAliasDefinitionError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type
     attr_reader :defs
 
@@ -389,6 +426,8 @@ module RBS
   end
 
   class MixinClassError < DefinitionError
+    include DetailedMessageable
+
     attr_reader :type_name
     attr_reader :member
 
@@ -426,6 +465,8 @@ module RBS
   end
 
   class RecursiveTypeAliasError < BaseError
+    include DetailedMessageable
+
     attr_reader :alias_names
     attr_reader :location
 
@@ -442,6 +483,8 @@ module RBS
   end
 
   class NonregularTypeAliasError < BaseError
+    include DetailedMessageable
+
     attr_reader :diagnostic
     attr_reader :location
 
@@ -454,6 +497,8 @@ module RBS
   end
 
   class CyclicTypeParameterBound < BaseError
+    include DetailedMessageable
+
     attr_reader :params, :type_name, :method_name, :location
 
     def initialize(type_name:, method_name:, params:, location:)
@@ -467,6 +512,8 @@ module RBS
   end
 
   class InconsistentClassModuleAliasError < BaseError
+    include DetailedMessageable
+
     attr_reader :alias_entry
 
     def initialize(entry)
@@ -482,9 +529,15 @@ module RBS
 
       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
+
+    def location
+      @alias_entry.decl.location
+    end
   end
 
   class CyclicClassAliasDefinitionError < BaseError
+    include DetailedMessageable
+
     attr_reader :alias_entry
 
     def initialize(entry)
@@ -492,5 +545,9 @@ module RBS
 
       super "#{Location.to_string(entry.decl.location&.[](:old_name))}: A #{alias_entry.decl.new_name} is a cyclic definition"
     end
+
+    def location
+      @alias_entry.decl.location
+    end
   end
 end

data/lib/rbs/file_finder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RBS
+  module FileFinder
+    module_function
+
+    def self.each_file(path, immediate:, skip_hidden:, &block)
+      return enum_for(__method__, path, immediate: immediate, skip_hidden: skip_hidden) unless block
+
+      case
+      when path.file?
+        if path.extname == ".rbs" || immediate
+          yield path
+        end
+
+      when path.directory?
+        if path.basename.to_s.start_with?("_")
+          if skip_hidden
+            unless immediate
+              return
+            end
+          end
+        end
+
+        path.children.sort.each do |child|
+          each_file(child, immediate: false, skip_hidden: skip_hidden, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rbs/parser_aux.rb

@@ -2,14 +2,14 @@
 
 module RBS
   class Parser
-    def self.parse_type(source, range: 0..., variables: [])
+    def self.parse_type(source, range: 0..., variables: [], require_eof: false)
       buf = buffer(source)
-      _parse_type(buf, range.begin || 0, range.end || buf.last_position, variables)
+      _parse_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof)
     end
 
-    def self.parse_method_type(source, range: 0..., variables: [])
+    def self.parse_method_type(source, range: 0..., variables: [], require_eof: false)
       buf = buffer(source)
-      _parse_method_type(buf, range.begin || 0, range.end || buf.last_position, variables)
+      _parse_method_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof)
     end
 
     def self.parse_signature(source)

data/lib/rbs/prototype/rb.rb

@@ -215,7 +215,8 @@ module RBS
           when :include
             args.each do |arg|
               if (name = const_to_name(arg, context: context))
-                decls << AST::Members::Include.new(
+                klass = context.singleton ? AST::Members::Extend : AST::Members::Include
+                decls << klass.new(
                   name: name,
                   args: [],
                   annotations: [],

data/lib/rbs/subtractor.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module RBS
+  class Subtractor
+    def initialize(minuend, subtrahend)
+      @minuend = minuend
+      @subtrahend = subtrahend
+    end
+
+    def call(minuend = @minuend, context: nil)
+      minuend.map do |decl|
+        case decl
+        when AST::Declarations::Constant
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.constant_name?(name)
+        when AST::Declarations::Interface
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.interface_name?(name)
+        when AST::Declarations::Class, AST::Declarations::Module
+          name = absolute_typename(decl.name, context: context)
+          case
+          when @subtrahend.class_decl?(name) && decl.is_a?(AST::Declarations::Class)
+            filter_members(decl, context: context)
+          when @subtrahend.module_decl?(name) && decl.is_a?(AST::Declarations::Module)
+            filter_members(decl, context: context)
+          when @subtrahend.constant_name?(name)
+            nil
+          else
+            decl
+          end
+        when AST::Declarations::Global
+          decl unless @subtrahend.global_decls[decl.name]
+        when AST::Declarations::TypeAlias
+          name = absolute_typename(decl.name, context: context)
+          decl unless @subtrahend.type_alias_decls[name]
+        when AST::Declarations::ClassAlias
+          name = absolute_typename(decl.new_name, context: context)
+          decl unless @subtrahend.class_alias?(name) || @subtrahend.class_decl?(name)
+        when AST::Declarations::ModuleAlias
+          name = absolute_typename(decl.new_name, context: context)
+          decl unless @subtrahend.module_alias?(name) || @subtrahend.module_decl?(name)
+        else
+          raise "unknwon decl: #{(_ = decl).class}"
+        end
+      end.compact
+    end
+
+    private def filter_members(decl, context:)
+      owner = absolute_typename(decl.name, context: context)
+
+      context = _ = [context, decl.name]
+      children = call(decl.each_decl.to_a, context: context) +
+        decl.each_member.reject { |m| member_exist?(owner, m, context: context) }
+      return nil if children.empty?
+
+      update_decl(decl, members: children)
+    end
+
+    private def member_exist?(owner, member, context:)
+      case member
+      when AST::Members::MethodDefinition
+        method_exist?(owner, member.name, member.kind)
+      when AST::Members::Alias
+        method_exist?(owner, member.new_name, member.kind)
+      when AST::Members::AttrReader
+        method_exist?(owner, member.name, member.kind)
+      when AST::Members::AttrWriter
+        method_exist?(owner, :"#{member.name}=", member.kind)
+      when AST::Members::AttrAccessor
+        # TODO: It unexpectedly removes attr_accessor even if either reader or writer does not exist in the subtrahend.
+        method_exist?(owner, member.name, member.kind) || method_exist?(owner, :"#{member.name}=", member.kind)
+      when AST::Members::InstanceVariable
+        ivar_exist?(owner, member.name, :instance)
+      when AST::Members::ClassInstanceVariable
+        ivar_exist?(owner, member.name, :singleton)
+      when AST::Members::ClassVariable
+        cvar_exist?(owner, member.name)
+      when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+        mixin_exist?(owner, member, context: context)
+      when AST::Members::Public, AST::Members::Private
+        # They should not be removed even if the subtrahend has them.
+        false
+      else
+        raise "unknown member: #{(_ = member).class}"
+      end
+    end
+
+    private def method_exist?(owner, method_name, kind)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::MethodDefinition
+          m.name == method_name && m.kind == kind
+        when AST::Members::Alias
+          m.new_name == method_name && m.kind == kind
+        when AST::Members::AttrReader
+          m.name == method_name && m.kind == kind
+        when AST::Members::AttrWriter
+          :"#{m.name}=" == method_name && m.kind == kind
+        when AST::Members::AttrAccessor
+          (m.name == method_name || :"#{m.name}=" == method_name) && m.kind == kind
+        end
+      end
+    end
+
+    private def ivar_exist?(owner, name, kind)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::InstanceVariable
+          m.name == name
+        when AST::Members::Attribute
+          ivar_name = m.ivar_name == false ? nil : m.ivar_name || :"@#{m.name}"
+          ivar_name == name && m.kind == kind
+        end
+      end
+    end
+
+    private def cvar_exist?(owner, name)
+      each_member(owner).any? do |m|
+        case m
+        when AST::Members::ClassVariable
+          m.name == name
+        end
+      end
+    end
+
+    private def each_member(owner, &block)
+      return enum_for((__method__ or raise), owner) unless block
+
+      entry = @subtrahend.class_decls[owner]
+      return unless entry
+      decls = entry.decls.map { |d| d.decl }
+
+      decls.each { |d| d.members.each { |m| block.call(m) } }
+    end
+
+    private def mixin_exist?(owner, mixin, context:)
+      candidates = typename_candidates(mixin.name, context: context)
+      each_member(owner).any? do |m|
+        case m
+        when mixin.class
+          # @type var m: AST::Members::Include | AST::Members::Extend | AST::Members::Prepend
+          candidates.include?(m.name)
+        end
+      end
+    end
+
+    private def update_decl(decl, members:)
+      case decl
+      when AST::Declarations::Class
+        decl.class.new(name: decl.name, type_params: decl.type_params, super_class: decl.super_class,
+                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
+                        members: members)
+      when AST::Declarations::Module
+        decl.class.new(name: decl.name, type_params: decl.type_params, self_types: decl.self_types,
+                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
+                        members: members)
+      end
+    end
+
+    private def absolute_typename(name, context:)
+      while context
+        ns = context[1] or raise
+        name = name.with_prefix(ns.to_namespace)
+        context = _ = context[0]
+      end
+      name.absolute!
+    end
+
+    private def typename_candidates(name, context:)
+      ret = [name.absolute!, name.relative!]
+      return ret if name.absolute?
+
+      while context
+        ns = context[1] or raise
+        name = name.with_prefix(ns.to_namespace)
+        ret.concat [name.absolute!, name.relative!]
+
+        context = _ = context[0]
+      end
+
+      ret
+    end
+  end
+end

data/lib/rbs/vendorer.rb

@@ -31,7 +31,7 @@ module RBS
 
       if core_root = loader.core_root
         RBS.logger.info "Vendoring core RBSs in #{vendor_dir + "core"}..."
-        loader.each_file(core_root, immediate: false, skip_hidden: true) do |file_path|
+        FileFinder.each_file(core_root, immediate: false, skip_hidden: true) do |file_path|
           paths << [file_path, Pathname("core") + file_path.relative_path_from(core_root)]
         end
       end
@@ -43,7 +43,7 @@ module RBS
 
           RBS.logger.info "Vendoring #{lib.name}(#{spec.version}) RBSs in #{vendor_dir + dest_dir}..."
 
-          loader.each_file(path, skip_hidden: true, immediate: false) do |file_path|
+          FileFinder.each_file(path, skip_hidden: true, immediate: false) do |file_path|
             paths << [file_path, dest_dir + file_path.relative_path_from(path)]
           end
 
@@ -52,7 +52,7 @@ module RBS
 
           RBS.logger.info "Vendoring #{lib.name}(#{path.version}) RBSs in #{vendor_dir + dest_dir}..."
 
-          loader.each_file(path.path, skip_hidden: true, immediate: false) do |file_path|
+          FileFinder.each_file(path.path, skip_hidden: true, immediate: false) do |file_path|
             paths << [file_path, dest_dir + file_path.relative_path_from(path.path)]
           end
         else

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.0.4"
+  VERSION = "3.1.0"
 end

data/lib/rbs/writer.rb

@@ -167,6 +167,18 @@ module RBS
           puts "type #{name_and_params(decl.name, decl.type_params)} = #{decl.type}"
         }
 
+      when AST::Declarations::ClassAlias
+        write_comment decl.comment
+        write_loc_source(decl) {
+          puts "class #{decl.new_name} = #{decl.old_name}"
+        }
+
+      when AST::Declarations::ModuleAlias
+        write_comment decl.comment
+        write_loc_source(decl) {
+          puts "module #{decl.new_name} = #{decl.old_name}"
+        }
+
       when AST::Declarations::Interface
         write_comment decl.comment
         write_annotation decl.annotations

data/lib/rbs.rb

@@ -16,6 +16,7 @@ require "rbs/namespace"
 require "rbs/type_name"
 require "rbs/types"
 require "rbs/method_type"
+require "rbs/file_finder"
 require "rbs/ast/type_param"
 require "rbs/ast/directives"
 require "rbs/ast/declarations"
@@ -46,6 +47,7 @@ require "rbs/vendorer"
 require "rbs/validator"
 require "rbs/factory"
 require "rbs/repository"
+require "rbs/subtractor"
 require "rbs/ancestor_graph"
 require "rbs/locator"
 require "rbs/type_alias_dependency"

data/sig/cli.rbs

@@ -76,6 +76,8 @@ module RBS
 
     def run_annotate: (Array[String], top) -> void
 
+    def run_subtract: (Array[String], top) -> void
+
     def test_opt: (LibraryOptions) -> String?
 
     def collection_options: (Array[String]) -> OptionParser

data/sig/collection/config/lockfile_generator.rbs

@@ -36,7 +36,9 @@ module RBS
 
         # 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
+        # * If `skip:` is true, it skips adding the gem, but adds it's dependencies.
+        #
+        def assign_gem: (name: String, version: String?, src_data: Sources::source_entry?, ignored_gems: Set[String], ?skip: bool) -> void
 
         def assign_stdlib: (name: String, from_gem: String?) -> void
 

data/sig/environment_loader.rbs

@@ -3,23 +3,25 @@ module RBS
   #
   # Set up your configuration through repository and `#add` method.
   #
-  #   # Set up the repository to load library RBSs from.
-  #   repo = RBS::Repository.default
-  #   repo.add(Pathname("vendor/rbs/gem-rbs"))
-  #   repo.add(Pathname("vendor/rbs/internal-rbs"))
+  # ```ruby
+  # # Set up the repository to load library RBSs from.
+  # repo = RBS::Repository.default
+  # repo.add(Pathname("vendor/rbs/gem-rbs"))
+  # repo.add(Pathname("vendor/rbs/internal-rbs"))
   #
-  #   loader = RBS::EnvironmentLoader.new(repository: repo)
+  # loader = RBS::EnvironmentLoader.new(repository: repo)
   #
-  #   # Add libraries to load RBS files.
-  #   loader.add(library: "minitest")
-  #   loader.add(library: "rbs", version: "1.0.0")
+  # # Add libraries to load RBS files.
+  # loader.add(library: "minitest")
+  # loader.add(library: "rbs", version: "1.0.0")
   #
-  #   # Add dirs to load RBS files from.
-  #   loader.add(path: Pathname("sig"))
+  # # Add dirs to load RBS files from.
+  # loader.add(path: Pathname("sig"))
   #
-  #   # Load RBSs into an environment.
-  #   environment = RBS::Environment.new()
-  #   loader.load(env: environment)
+  # # Load RBSs into an environment.
+  # environment = RBS::Environment.new()
+  # loader.load(env: environment)
+  # ```
   #
   class EnvironmentLoader
     class UnknownLibraryError < StandardError
@@ -35,6 +37,8 @@ module RBS
       def initialize: (name: String, version: String?) -> void
     end
 
+    include FileFinder
+
     DEFAULT_CORE_ROOT: Pathname
 
     attr_reader core_root: Pathname?
@@ -103,7 +107,5 @@ module RBS
     def each_signature: () { (source, Pathname, Buffer, Array[AST::Declarations::t], Array[AST::Directives::t]) -> void } -> void
 
     def each_dir: { (source, Pathname) -> void } -> void
-
-    def each_file: (Pathname path, immediate: boolish, skip_hidden: boolish) { (Pathname) -> void } -> void
   end
 end

data/sig/file_finder.rbs

@@ -0,0 +1,6 @@
+module RBS
+  module FileFinder
+    def self?.each_file: (Pathname path, immediate: boolish, skip_hidden: boolish) { (Pathname) -> void } -> void
+                        | (Pathname path, immediate: boolish, skip_hidden: boolish) -> Enumerator[Pathname, void]
+  end
+end

data/sig/manifest.yaml

@@ -5,3 +5,4 @@ dependencies:
   - name: optparse
   - name: tsort
   - name: rdoc
+  - name: abbrev

data/sig/parser.rbs

@@ -2,8 +2,7 @@ module RBS
   class Parser
     # Parse a method type and return it
     #
-    # When `pos` keyword is specified, skips the first `pos` characters from the input.
-    # If no token is left in the input, it returns `nil`.
+    # When `range` keyword is specified, it starts parsing from the `begin` to the `endo` the range.
     #
     # ```ruby
     # RBS::Parser.parse_method_type("() -> void")                                # => `() -> void`
@@ -12,12 +11,21 @@ module RBS
     # RBS::Parser.parse_method_type("() -> void () -> String", range: 23...)     # => nil
     # ```
     #
-    def self.parse_method_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol]) -> MethodType?
+    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
+    # (Defaults to `false`.)
+    #
+    # ```ruby
+    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: false)    # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: true)     # => Raises an error
+    #
+    # RBS::Parser.parse_method_type("", require_eof: true)                            # => nil
+    # ```
+    #
+    def self.parse_method_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> MethodType?
 
     # Parse a type and return it
     #
-    # When `pos` keyword is specified, skips the first `pos` characters from the input.
-    # If no token is left in the input, it returns `nil`.
+    # When `range` keyword is specified, it starts parsing from the `begin` to the `endo` the range.
     #
     # ```ruby
     # RBS::Parser.parse_type("String")                          # => `String`
@@ -26,7 +34,17 @@ module RBS
     # RBS::Parser.parse_type("String Integer", pos: 14...)      # => nil
     # ```
     #
-    def self.parse_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol]) -> Types::t?
+    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
+    # (Defaults to `false`.)
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("String untyped", require_eof: false)    # => `String`
+    # RBS::Parser.parse_type("String untyped", require_eof: true)     # => Raises an error
+    #
+    # RBS::Parser.parse_type("", require_eof: true)                   # => nil
+    # ```
+    #
+    def self.parse_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> Types::t?
 
     # Parse whole RBS file and return an array of declarations
     #
@@ -38,9 +56,9 @@ module RBS
 
     def self.buffer: (String | Buffer source) -> Buffer
 
-    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> Types::t?
+    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> Types::t?
 
-    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> MethodType?
+    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
 
     def self._parse_signature: (Buffer, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]