irb 1.8.2 → 1.9.0

data/lib/irb/type_completion/types.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require_relative 'methods'
+
+module IRB
+  module TypeCompletion
+    module Types
+      OBJECT_TO_TYPE_SAMPLE_SIZE = 50
+
+      singleton_class.attr_reader :rbs_builder, :rbs_load_error
+
+      def self.preload_in_thread
+        return if @preload_started
+
+        @preload_started = true
+        Thread.new do
+          load_rbs_builder
+        end
+      end
+
+      def self.load_rbs_builder
+        require 'rbs'
+        require 'rbs/cli'
+        loader = RBS::CLI::LibraryOptions.new.loader
+        loader.add path: Pathname('sig')
+        @rbs_builder = RBS::DefinitionBuilder.new env: RBS::Environment.from_loader(loader).resolve_type_names
+      rescue LoadError, StandardError => e
+        @rbs_load_error = e
+        nil
+      end
+
+      def self.class_name_of(klass)
+        klass = klass.superclass if klass.singleton_class?
+        Methods::MODULE_NAME_METHOD.bind_call klass
+      end
+
+      def self.rbs_search_method(klass, method_name, singleton)
+        klass.ancestors.each do |ancestor|
+          name = class_name_of ancestor
+          next unless name && rbs_builder
+          type_name = RBS::TypeName(name).absolute!
+          definition = (singleton ? rbs_builder.build_singleton(type_name) : rbs_builder.build_instance(type_name)) rescue nil
+          method = definition.methods[method_name] if definition
+          return method if method
+        end
+        nil
+      end
+
+      def self.method_return_type(type, method_name)
+        receivers = type.types.map do |t|
+          case t
+          in SingletonType
+            [t, t.module_or_class, true]
+          in InstanceType
+            [t, t.klass, false]
+          end
+        end
+        types = receivers.flat_map do |receiver_type, klass, singleton|
+          method = rbs_search_method klass, method_name, singleton
+          next [] unless method
+          method.method_types.map do |method|
+            from_rbs_type(method.type.return_type, receiver_type, {})
+          end
+        end
+        UnionType[*types]
+      end
+
+      def self.rbs_methods(type, method_name, args_types, kwargs_type, has_block)
+        return [] unless rbs_builder
+
+        receivers = type.types.map do |t|
+          case t
+          in SingletonType
+            [t, t.module_or_class, true]
+          in InstanceType
+            [t, t.klass, false]
+          end
+        end
+        has_splat = args_types.include?(nil)
+        methods_with_score = receivers.flat_map do |receiver_type, klass, singleton|
+          method = rbs_search_method klass, method_name, singleton
+          next [] unless method
+          method.method_types.map do |method_type|
+            score = 0
+            score += 2 if !!method_type.block == has_block
+            reqs = method_type.type.required_positionals
+            opts = method_type.type.optional_positionals
+            rest = method_type.type.rest_positionals
+            trailings = method_type.type.trailing_positionals
+            keyreqs = method_type.type.required_keywords
+            keyopts = method_type.type.optional_keywords
+            keyrest = method_type.type.rest_keywords
+            args = args_types
+            if kwargs_type&.any? && keyreqs.empty? && keyopts.empty? && keyrest.nil?
+              kw_value_type = UnionType[*kwargs_type.values]
+              args += [InstanceType.new(Hash, K: SYMBOL, V: kw_value_type)]
+            end
+            if has_splat
+              score += 1 if args.count(&:itself) <= reqs.size + opts.size + trailings.size
+            elsif reqs.size + trailings.size <= args.size && (rest || args.size <= reqs.size + opts.size + trailings.size)
+              score += 2
+              centers = args[reqs.size...-trailings.size]
+              given = args.first(reqs.size) + centers.take(opts.size) + args.last(trailings.size)
+              expected = (reqs + opts.take(centers.size) + trailings).map(&:type)
+              if rest
+                given << UnionType[*centers.drop(opts.size)]
+                expected << rest.type
+              end
+              if given.any?
+                score += given.zip(expected).count do |t, e|
+                  e = from_rbs_type e, receiver_type
+                  intersect?(t, e) || (intersect?(STRING, e) && t.methods.include?(:to_str)) || (intersect?(INTEGER, e) && t.methods.include?(:to_int)) || (intersect?(ARRAY, e) && t.methods.include?(:to_ary))
+                end.fdiv(given.size)
+              end
+            end
+            [[method_type, given || [], expected || []], score]
+          end
+        end
+        max_score = methods_with_score.map(&:last).max
+        methods_with_score.select { _2 == max_score }.map(&:first)
+      end
+
+      def self.intersect?(a, b)
+        atypes = a.types.group_by(&:class)
+        btypes = b.types.group_by(&:class)
+        if atypes[SingletonType] && btypes[SingletonType]
+          aa, bb = [atypes, btypes].map {|types| types[SingletonType].map(&:module_or_class) }
+          return true if (aa & bb).any?
+        end
+
+        aa, bb = [atypes, btypes].map {|types| (types[InstanceType] || []).map(&:klass) }
+        (aa.flat_map(&:ancestors) & bb).any?
+      end
+
+      def self.type_from_object(object)
+        case object
+        when Array
+          InstanceType.new Array, { Elem: union_type_from_objects(object) }
+        when Hash
+          InstanceType.new Hash, { K: union_type_from_objects(object.keys), V: union_type_from_objects(object.values) }
+        when Module
+          SingletonType.new object
+        else
+          klass = Methods::OBJECT_SINGLETON_CLASS_METHOD.bind_call(object) rescue Methods::OBJECT_CLASS_METHOD.bind_call(object)
+          InstanceType.new klass
+        end
+      end
+
+      def self.union_type_from_objects(objects)
+        values = objects.size <= OBJECT_TO_TYPE_SAMPLE_SIZE ? objects : objects.sample(OBJECT_TO_TYPE_SAMPLE_SIZE)
+        klasses = values.map { Methods::OBJECT_CLASS_METHOD.bind_call(_1) }
+        UnionType[*klasses.uniq.map { InstanceType.new _1 }]
+      end
+
+      class SingletonType
+        attr_reader :module_or_class
+        def initialize(module_or_class)
+          @module_or_class = module_or_class
+        end
+        def transform() = yield(self)
+        def methods() = @module_or_class.methods
+        def all_methods() = methods | Kernel.methods
+        def constants() = @module_or_class.constants
+        def types() = [self]
+        def nillable?() = false
+        def nonnillable() = self
+        def inspect
+          "#{module_or_class}.itself"
+        end
+      end
+
+      class InstanceType
+        attr_reader :klass, :params
+        def initialize(klass, params = {})
+          @klass = klass
+          @params = params
+        end
+        def transform() = yield(self)
+        def methods() = rbs_methods.select { _2.public? }.keys | @klass.instance_methods
+        def all_methods() = rbs_methods.keys | @klass.instance_methods | @klass.private_instance_methods
+        def constants() = []
+        def types() = [self]
+        def nillable?() = (@klass == NilClass)
+        def nonnillable() = self
+        def rbs_methods
+          name = Types.class_name_of(@klass)
+          return {} unless name && Types.rbs_builder
+
+          type_name = RBS::TypeName(name).absolute!
+          Types.rbs_builder.build_instance(type_name).methods rescue {}
+        end
+        def inspect
+          if params.empty?
+            inspect_without_params
+          else
+            params_string = "[#{params.map { "#{_1}: #{_2.inspect}" }.join(', ')}]"
+            "#{inspect_without_params}#{params_string}"
+          end
+        end
+        def inspect_without_params
+          if klass == NilClass
+            'nil'
+          elsif klass == TrueClass
+            'true'
+          elsif klass == FalseClass
+            'false'
+          else
+            klass.singleton_class? ? klass.superclass.to_s : klass.to_s
+          end
+        end
+      end
+
+      NIL = InstanceType.new NilClass
+      OBJECT = InstanceType.new Object
+      TRUE = InstanceType.new TrueClass
+      FALSE = InstanceType.new FalseClass
+      SYMBOL = InstanceType.new Symbol
+      STRING = InstanceType.new String
+      INTEGER = InstanceType.new Integer
+      RANGE = InstanceType.new Range
+      REGEXP = InstanceType.new Regexp
+      FLOAT = InstanceType.new Float
+      RATIONAL = InstanceType.new Rational
+      COMPLEX = InstanceType.new Complex
+      ARRAY = InstanceType.new Array
+      HASH = InstanceType.new Hash
+      CLASS = InstanceType.new Class
+      MODULE = InstanceType.new Module
+      PROC = InstanceType.new Proc
+
+      class UnionType
+        attr_reader :types
+
+        def initialize(*types)
+          @types = []
+          singletons = []
+          instances = {}
+          collect = -> type do
+            case type
+            in UnionType
+              type.types.each(&collect)
+            in InstanceType
+              params = (instances[type.klass] ||= {})
+              type.params.each do |k, v|
+                (params[k] ||= []) << v
+              end
+            in SingletonType
+              singletons << type
+            end
+          end
+          types.each(&collect)
+          @types = singletons.uniq + instances.map do |klass, params|
+            InstanceType.new(klass, params.transform_values { |v| UnionType[*v] })
+          end
+        end
+
+        def transform(&block)
+          UnionType[*types.map(&block)]
+        end
+
+        def nillable?
+          types.any?(&:nillable?)
+        end
+
+        def nonnillable
+          UnionType[*types.reject { _1.is_a?(InstanceType) && _1.klass == NilClass }]
+        end
+
+        def self.[](*types)
+          type = new(*types)
+          if type.types.empty?
+            OBJECT
+          elsif type.types.size == 1
+            type.types.first
+          else
+            type
+          end
+        end
+
+        def methods() = @types.flat_map(&:methods).uniq
+        def all_methods() = @types.flat_map(&:all_methods).uniq
+        def constants() = @types.flat_map(&:constants).uniq
+        def inspect() = @types.map(&:inspect).join(' | ')
+      end
+
+      BOOLEAN = UnionType[TRUE, FALSE]
+
+      def self.array_of(*types)
+        type = types.size >= 2 ? UnionType[*types] : types.first || OBJECT
+        InstanceType.new Array, Elem: type
+      end
+
+      def self.from_rbs_type(return_type, self_type, extra_vars = {})
+        case return_type
+        when RBS::Types::Bases::Self
+          self_type
+        when RBS::Types::Bases::Bottom, RBS::Types::Bases::Nil
+          NIL
+        when RBS::Types::Bases::Any, RBS::Types::Bases::Void
+          OBJECT
+        when RBS::Types::Bases::Class
+          self_type.transform do |type|
+            case type
+            in SingletonType
+              InstanceType.new(self_type.module_or_class.is_a?(Class) ? Class : Module)
+            in InstanceType
+              SingletonType.new type.klass
+            end
+          end
+          UnionType[*types]
+        when RBS::Types::Bases::Bool
+          BOOLEAN
+        when RBS::Types::Bases::Instance
+          self_type.transform do |type|
+            if type.is_a?(SingletonType) && type.module_or_class.is_a?(Class)
+              InstanceType.new type.module_or_class
+            else
+              OBJECT
+            end
+          end
+        when RBS::Types::Union
+          UnionType[*return_type.types.map { from_rbs_type _1, self_type, extra_vars }]
+        when RBS::Types::Proc
+          PROC
+        when RBS::Types::Tuple
+          elem = UnionType[*return_type.types.map { from_rbs_type _1, self_type, extra_vars }]
+          InstanceType.new Array, Elem: elem
+        when RBS::Types::Record
+          InstanceType.new Hash, K: SYMBOL, V: OBJECT
+        when RBS::Types::Literal
+          InstanceType.new return_type.literal.class
+        when RBS::Types::Variable
+          if extra_vars.key? return_type.name
+            extra_vars[return_type.name]
+          elsif self_type.is_a? InstanceType
+            self_type.params[return_type.name] || OBJECT
+          elsif self_type.is_a? UnionType
+            types = self_type.types.filter_map do |t|
+              t.params[return_type.name] if t.is_a? InstanceType
+            end
+            UnionType[*types]
+          else
+            OBJECT
+          end
+        when RBS::Types::Optional
+          UnionType[from_rbs_type(return_type.type, self_type, extra_vars), NIL]
+        when RBS::Types::Alias
+          case return_type.name.name
+          when :int
+            INTEGER
+          when :boolish
+            BOOLEAN
+          when :string
+            STRING
+          else
+            # TODO: ???
+            OBJECT
+          end
+        when RBS::Types::Interface
+          # unimplemented
+          OBJECT
+        when RBS::Types::ClassInstance
+          klass = return_type.name.to_namespace.path.reduce(Object) { _1.const_get _2 }
+          if return_type.args
+            args = return_type.args.map { from_rbs_type _1, self_type, extra_vars }
+            names = rbs_builder.build_singleton(return_type.name).type_params
+            params = names.map.with_index { [_1, args[_2] || OBJECT] }.to_h
+          end
+          InstanceType.new klass, params || {}
+        end
+      end
+
+      def self.method_return_bottom?(method)
+        method.type.return_type.is_a? RBS::Types::Bases::Bottom
+      end
+
+      def self.match_free_variables(vars, types, values)
+        accumulator = {}
+        types.zip values do |t, v|
+          _match_free_variable(vars, t, v, accumulator) if v
+        end
+        accumulator.transform_values { UnionType[*_1] }
+      end
+
+      def self._match_free_variable(vars, rbs_type, value, accumulator)
+        case [rbs_type, value]
+        in [RBS::Types::Variable,]
+          (accumulator[rbs_type.name] ||= []) << value if vars.include? rbs_type.name
+        in [RBS::Types::ClassInstance, InstanceType]
+          names = rbs_builder.build_singleton(rbs_type.name).type_params
+          names.zip(rbs_type.args).each do |name, arg|
+            v = value.params[name]
+            _match_free_variable vars, arg, v, accumulator if v
+          end
+        in [RBS::Types::Tuple, InstanceType] if value.klass == Array
+          v = value.params[:Elem]
+          rbs_type.types.each do |t|
+            _match_free_variable vars, t, v, accumulator
+          end
+        in [RBS::Types::Record, InstanceType] if value.klass == Hash
+          # TODO
+        in [RBS::Types::Interface,]
+          definition = rbs_builder.build_interface rbs_type.name
+          convert = {}
+          definition.type_params.zip(rbs_type.args).each do |from, arg|
+            convert[from] = arg.name if arg.is_a? RBS::Types::Variable
+          end
+          return if convert.empty?
+          ac = {}
+          definition.methods.each do |method_name, method|
+            return_type = method_return_type value, method_name
+            method.defs.each do |method_def|
+              interface_return_type = method_def.type.type.return_type
+              _match_free_variable convert, interface_return_type, return_type, ac
+            end
+          end
+          convert.each do |from, to|
+            values = ac[from]
+            (accumulator[to] ||= []).concat values if values
+          end
+        else
+        end
+      end
+    end
+  end
+end

data/lib/irb/version.rb

@@ -5,7 +5,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.8.2"
+  VERSION = "1.9.0"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2023-10-12"
+  @LAST_UPDATE_DATE = "2023-11-11"
 end

data/lib/irb.rb

@@ -140,6 +140,10 @@ require_relative "irb/debug"
 #
 #     IRB.conf[:USE_AUTOCOMPLETE] = false
 #
+# To enable enhanced completion using type information, add the following to your +.irbrc+:
+#
+#     IRB.conf[:COMPLETOR] = :type
+#
 # === History
 #
 # By default, irb will store the last 1000 commands you used in
@@ -367,24 +371,6 @@ module IRB
   # An exception raised by IRB.irb_abort
   class Abort < Exception;end
 
-  @CONF = {}
-  # Displays current configuration.
-  #
-  # Modifying the configuration is achieved by sending a message to IRB.conf.
-  #
-  # See IRB@Configuration for more information.
-  def IRB.conf
-    @CONF
-  end
-
-  # Returns the current version of IRB, including release version and last
-  # updated date.
-  def IRB.version
-    if v = @CONF[:VERSION] then return v end
-
-    @CONF[:VERSION] = format("irb %s (%s)", @RELEASE_VERSION, @LAST_UPDATE_DATE)
-  end
-
   # The current IRB::Context of the session, see IRB.conf
   #
   #   irb
@@ -431,6 +417,11 @@ module IRB
     PROMPT_MAIN_TRUNCATE_OMISSION = '...'.freeze
     CONTROL_CHARACTERS_PATTERN = "\x00-\x1F".freeze
 
+    # Returns the current context of this irb session
+    attr_reader :context
+    # The lexer used by this irb session
+    attr_accessor :scanner
+
     # Creates a new irb session
     def initialize(workspace = nil, input_method = nil)
       @context = Context.new(self, workspace, input_method)
@@ -509,41 +500,6 @@ module IRB
       end
     end
 
-    # Returns the current context of this irb session
-    attr_reader :context
-    # The lexer used by this irb session
-    attr_accessor :scanner
-
-    private def generate_prompt(opens, continue, line_offset)
-      ltype = @scanner.ltype_from_open_tokens(opens)
-      indent = @scanner.calc_indent_level(opens)
-      continue = opens.any? || continue
-      line_no = @line_no + line_offset
-
-      if ltype
-        f = @context.prompt_s
-      elsif continue
-        f = @context.prompt_c
-      else
-        f = @context.prompt_i
-      end
-      f = "" unless f
-      if @context.prompting?
-        p = format_prompt(f, ltype, indent, line_no)
-      else
-        p = ""
-      end
-      if @context.auto_indent_mode and !@context.io.respond_to?(:auto_indent)
-        unless ltype
-          prompt_i = @context.prompt_i.nil? ? "" : @context.prompt_i
-          ind = format_prompt(prompt_i, ltype, indent, line_no)[/.*\z/].size +
-            indent * 2 - p.size
-          p += " " * ind if ind > 0
-        end
-      end
-      p
-    end
-
     # Evaluates input for this session.
     def eval_input
       configure_io
@@ -835,16 +791,6 @@ module IRB
       end
     end
 
-    # Evaluates the given block using the given +context+ as the Context.
-    def suspend_context(context)
-      @context, back_context = context, @context
-      begin
-        yield back_context
-      ensure
-        @context = back_context
-      end
-    end
-
     # Handler for the signal SIGINT, see Kernel#trap for more information.
     def signal_handle
       unless @context.ignore_sigint?
@@ -880,52 +826,6 @@ module IRB
       end
     end
 
-    private def truncate_prompt_main(str) # :nodoc:
-      str = str.tr(CONTROL_CHARACTERS_PATTERN, ' ')
-      if str.size <= PROMPT_MAIN_TRUNCATE_LENGTH
-        str
-      else
-        str[0, PROMPT_MAIN_TRUNCATE_LENGTH - PROMPT_MAIN_TRUNCATE_OMISSION.size] + PROMPT_MAIN_TRUNCATE_OMISSION
-      end
-    end
-
-    private def format_prompt(format, ltype, indent, line_no) # :nodoc:
-      format.gsub(/%([0-9]+)?([a-zA-Z])/) do
-        case $2
-        when "N"
-          @context.irb_name
-        when "m"
-          truncate_prompt_main(@context.main.to_s)
-        when "M"
-          truncate_prompt_main(@context.main.inspect)
-        when "l"
-          ltype
-        when "i"
-          if indent < 0
-            if $1
-              "-".rjust($1.to_i)
-            else
-              "-"
-            end
-          else
-            if $1
-              format("%" + $1 + "d", indent)
-            else
-              indent.to_s
-            end
-          end
-        when "n"
-          if $1
-            format("%" + $1 + "d", line_no)
-          else
-            line_no.to_s
-          end
-        when "%"
-          "%"
-        end
-      end
-    end
-
     def output_value(omit = false) # :nodoc:
       str = @context.inspect_last_value
       multiline_p = str.include?("\n")
@@ -978,28 +878,84 @@ module IRB
       end
       format("#<%s: %s>", self.class, ary.join(", "))
     end
-  end
 
-  def @CONF.inspect
-    IRB.version unless self[:VERSION]
-
-    array = []
-    for k, v in sort{|a1, a2| a1[0].id2name <=> a2[0].id2name}
-      case k
-      when :MAIN_CONTEXT, :__TMP__EHV__
-        array.push format("CONF[:%s]=...myself...", k.id2name)
-      when :PROMPT
-        s = v.collect{
-          |kk, vv|
-          ss = vv.collect{|kkk, vvv| ":#{kkk.id2name}=>#{vvv.inspect}"}
-          format(":%s=>{%s}", kk.id2name, ss.join(", "))
-        }
-        array.push format("CONF[:%s]={%s}", k.id2name, s.join(", "))
+    private
+
+    def generate_prompt(opens, continue, line_offset)
+      ltype = @scanner.ltype_from_open_tokens(opens)
+      indent = @scanner.calc_indent_level(opens)
+      continue = opens.any? || continue
+      line_no = @line_no + line_offset
+
+      if ltype
+        f = @context.prompt_s
+      elsif continue
+        f = @context.prompt_c
+      else
+        f = @context.prompt_i
+      end
+      f = "" unless f
+      if @context.prompting?
+        p = format_prompt(f, ltype, indent, line_no)
+      else
+        p = ""
+      end
+      if @context.auto_indent_mode and !@context.io.respond_to?(:auto_indent)
+        unless ltype
+          prompt_i = @context.prompt_i.nil? ? "" : @context.prompt_i
+          ind = format_prompt(prompt_i, ltype, indent, line_no)[/.*\z/].size +
+            indent * 2 - p.size
+          p += " " * ind if ind > 0
+        end
+      end
+      p
+    end
+
+    def truncate_prompt_main(str) # :nodoc:
+      str = str.tr(CONTROL_CHARACTERS_PATTERN, ' ')
+      if str.size <= PROMPT_MAIN_TRUNCATE_LENGTH
+        str
       else
-        array.push format("CONF[:%s]=%s", k.id2name, v.inspect)
+        str[0, PROMPT_MAIN_TRUNCATE_LENGTH - PROMPT_MAIN_TRUNCATE_OMISSION.size] + PROMPT_MAIN_TRUNCATE_OMISSION
+      end
+    end
+
+    def format_prompt(format, ltype, indent, line_no) # :nodoc:
+      format.gsub(/%([0-9]+)?([a-zA-Z])/) do
+        case $2
+        when "N"
+          @context.irb_name
+        when "m"
+          truncate_prompt_main(@context.main.to_s)
+        when "M"
+          truncate_prompt_main(@context.main.inspect)
+        when "l"
+          ltype
+        when "i"
+          if indent < 0
+            if $1
+              "-".rjust($1.to_i)
+            else
+              "-"
+            end
+          else
+            if $1
+              format("%" + $1 + "d", indent)
+            else
+              indent.to_s
+            end
+          end
+        when "n"
+          if $1
+            format("%" + $1 + "d", line_no)
+          else
+            line_no.to_s
+          end
+        when "%"
+          "%"
+        end
       end
     end
-    array.join("\n")
   end
 end
 

data/man/irb.1

@@ -140,6 +140,13 @@ Use autocompletion.
 Don't use autocompletion.
 .Pp
 .Pp
+.It Fl -regexp-completor
+Use regexp based completion.
+.Pp
+.It Fl -type-completor
+Use type based completion.
+.Pp
+.Pp
 .It Fl -verbose
 Show details.
 .Pp