repl_type_completor 0.1.0

data/lib/repl_type_completor/types.rb

@@ -0,0 +1,428 @@
+# frozen_string_literal: true
+
+require_relative 'methods'
+
+module ReplTypeCompletor
+  module Types
+    OBJECT_TO_TYPE_SAMPLE_SIZE = 50
+
+    singleton_class.attr_reader :rbs_builder, :rbs_load_error
+
+    def self.rbs_load_started?
+      !!@load_started
+    end
+
+    def self.preload_rbs_builder
+      return if rbs_load_started?
+      @load_started = true
+      Thread.new do
+        load_rbs_builder
+      end
+    end
+
+    def self.load_rbs_builder
+      @load_started = true
+      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

data/lib/repl_type_completor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ReplTypeCompletor
+  VERSION = "0.1.0"
+end

data/lib/repl_type_completor.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative 'repl_type_completor/version'
+require_relative 'repl_type_completor/type_analyzer'
+require_relative 'repl_type_completor/result'
+
+module ReplTypeCompletor
+  class << self
+    attr_reader :last_completion_error
+
+    def rbs_load_error
+      Types.rbs_load_error
+    end
+
+    def rbs_load_started?
+      Types.rbs_load_started?
+    end
+
+    def rbs_loaded?
+      !!Types.rbs_builder
+    end
+
+    def load_rbs
+      Types.load_rbs_builder unless rbs_loaded?
+    end
+
+    def preload_rbs
+      Types.preload_rbs_builder
+    end
+
+    def analyze(code, binding:, filename: nil)
+      verbose, $VERBOSE = $VERBOSE, nil
+      result = analyze_code(code, binding)
+      Result.new(result, binding, filename) if result
+    rescue Exception => e
+      handle_exception(e)
+      nil
+    ensure
+      $VERBOSE = verbose
+    end
+
+    def handle_exception(e)
+      @last_completion_error = e
+    end
+
+    def info
+      require 'rbs'
+      prism_info = "Prism: #{Prism::VERSION}"
+      rbs_info = "RBS: #{RBS::VERSION}"
+      if rbs_load_error
+        rbs_info << " #{rbs_load_error.inspect}"
+      elsif !rbs_load_started?
+        rbs_info << ' signatures not loaded'
+      elsif !rbs_loaded?
+        rbs_info << ' signatures loading'
+      end
+      "ReplTypeCompletor: #{VERSION}, #{prism_info}, #{rbs_info}"
+    end
+
+    private
+
+    def analyze_code(code, binding = Object::TOPLEVEL_BINDING)
+      ast = Prism.parse(code, scopes: [binding.local_variables]).value
+      *parents, target_node = find_target ast, code.bytesize
+      return unless target_node
+
+      calculate_scope = -> { TypeAnalyzer.calculate_target_type_scope(binding, parents, target_node).last }
+      calculate_type_scope = ->(node) { TypeAnalyzer.calculate_target_type_scope binding, [*parents, target_node], node }
+
+      case target_node
+      when Prism::StringNode, Prism::InterpolatedStringNode
+        call_node, args_node = parents.last(2)
+        return unless call_node.is_a?(Prism::CallNode) && call_node.receiver.nil?
+        return unless args_node.is_a?(Prism::ArgumentsNode) && args_node.arguments.size == 1
+
+        content = code.byteslice(target_node.opening_loc.end_offset..)
+        case call_node.name
+        when :require
+          [:require, content]
+        when :require_relative
+          [:require_relative, content]
+        end
+      when Prism::SymbolNode
+        name = target_node.value.to_s
+        if parents.last.is_a? Prism::BlockArgumentNode # method(&:target)
+          receiver_type, _scope = calculate_type_scope.call target_node
+          [:call, name, receiver_type, false]
+        else
+          [:symbol, name] unless name.empty?
+        end
+      when Prism::CallNode
+        name = target_node.message.to_s
+        return [:lvar_or_method, name, calculate_scope.call] if target_node.receiver.nil?
+
+        self_call = target_node.receiver.is_a? Prism::SelfNode
+        op = target_node.call_operator
+        receiver_type, _scope = calculate_type_scope.call target_node.receiver
+        receiver_type = receiver_type.nonnillable if op == '&.'
+        [op == '::' ? :call_or_const : :call, name, receiver_type, self_call]
+      when Prism::LocalVariableReadNode, Prism::LocalVariableTargetNode
+        [:lvar_or_method, target_node.name.to_s, calculate_scope.call]
+      when Prism::ConstantReadNode, Prism::ConstantTargetNode
+        name = target_node.name.to_s
+        if parents.last.is_a? Prism::ConstantPathNode
+          path_node = parents.last
+          if path_node.parent # A::B
+            receiver, scope = calculate_type_scope.call(path_node.parent)
+            [:const, name, receiver, scope]
+          else # ::A
+            scope = calculate_scope.call
+            [:const, name, Types::SingletonType.new(Object), scope]
+          end
+        else
+          [:const, name, nil, calculate_scope.call]
+        end
+      when Prism::GlobalVariableReadNode, Prism::GlobalVariableTargetNode
+        [:gvar, target_node.name.to_s, calculate_scope.call]
+      when Prism::InstanceVariableReadNode, Prism::InstanceVariableTargetNode
+        [:ivar, target_node.name.to_s, calculate_scope.call]
+      when Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
+        [:cvar, target_node.name.to_s, calculate_scope.call]
+      end
+    end
+
+    def find_target(node, position)
+      case node
+      when Prism::StringNode
+        # Unclosed quoted string has empty content and empty closing
+        return [node] if node.opening && node.closing&.empty?
+      when Prism::InterpolatedStringNode
+        # Unclosed double quoted string is InterpolatedStringNode with empty parts
+        return [node] if node.parts.empty? && node.opening && node.closing&.empty?
+      end
+
+      node.compact_child_nodes.each do |n|
+        match = find_target(n, position)
+        next unless match
+
+        match.unshift node
+        return match
+      end
+
+      [node] if node.location.end_offset == position
+    end
+  end
+end

data/sig/repl_type_completor.rbs

@@ -0,0 +1,19 @@
+module ReplTypeCompletor
+  VERSION: String
+
+  class Result
+    def completion_candidates: () -> Array[String]
+    def doc_namespace: (String) -> String?
+  end
+
+  def self.analyze: (String, binding: Binding, ?filename: String?) -> Result?
+
+  def self.rbs_load_error: () -> Exception?
+  def self.last_completion_error: () -> Exception?
+
+  def self.rbs_load_started?: () -> bool
+  def self.rbs_loaded?: () -> bool
+  def self.load_rbs: () -> void
+  def self.preload_rbs: () -> void
+  def self.info: () -> String
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: repl_type_completor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- tompng
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.18.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.18.0
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+description: Type based completion for REPL.
+email:
+- tomoyapenguin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/repl_type_completor.rb
+- lib/repl_type_completor/methods.rb
+- lib/repl_type_completor/require_paths.rb
+- lib/repl_type_completor/result.rb
+- lib/repl_type_completor/scope.rb
+- lib/repl_type_completor/type_analyzer.rb
+- lib/repl_type_completor/types.rb
+- lib/repl_type_completor/version.rb
+- sig/repl_type_completor.rbs
+homepage: https://github.com/ruby/repl_type_completor
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ruby/repl_type_completor
+  source_code_uri: https://github.com/ruby/repl_type_completor
+  documentation_uri: https://github.com/ruby/repl_type_completor
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Type based completion for REPL.
+test_files: []