katakata_irb 0.1.4 → 0.1.6

data/lib/katakata_irb/types.rb

@@ -4,27 +4,62 @@ require 'rbs/cli'
 module KatakataIrb; end
 module KatakataIrb::Types
   def self.rbs_builder
-    @rbs_builder ||= RBS::DefinitionBuilder.new(
-      env: RBS::Environment.from_loader(RBS::CLI::LibraryOptions.new.loader).resolve_type_names
-    )
+    @rbs_builder ||= load_rbs_builder
+  end
+
+  def self.load_rbs_builder
+    loader = RBS::CLI::LibraryOptions.new.loader
+    loader.add path: Pathname('sig')
+    RBS::DefinitionBuilder.new env: RBS::Environment.from_loader(loader).resolve_type_names
+  rescue => e
+    puts "\nKatakataIRB failed to initialize RBS::DefinitionBuild\n#{e}"
+    Object.new
   end
 
   Splat = Struct.new :item
 
+  MODULE_NAME_METHOD = Module.instance_method(:name)
+
+  def self.class_name_of(klass)
+    klass = klass.superclass if klass.singleton_class?
+    MODULE_NAME_METHOD.bind_call klass
+  end
+
   def self.rbs_search_method(klass, method_name, singleton)
     klass.ancestors.each do |ancestor|
-      next unless ancestor.name
-      type_name = RBS::TypeName(ancestor.name).absolute!
+      name = class_name_of ancestor
+      next unless name
+      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)
+      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 ProcType
+        [t, Proc, false]
+      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)
-    types = (type in UnionType) ? type.types : [type]
-    receivers = types.map do |t|
+    receivers = type.types.map do |t|
       case t
       in ProcType
         [t, Proc, false]
@@ -60,8 +95,15 @@ module KatakataIrb::Types
             given << UnionType[*centers.drop(opts.size)]
             expected << rest.type
           end
-          score += given.zip(expected).count do |t, e|
-            intersect? t, from_rbs_type(e, receiver_type)
+          score += given.zip(expected).sum do |t, e|
+            e = from_rbs_type e, receiver_type
+            if intersect? t, e
+              1
+            elsif (intersect?(STRING, e) && t.methods.include?(:to_str)) || (intersect?(INTEGER, e) && t.methods.include?(:to_int)) || (intersect?(ARRAY, e) && t.methods.include?(:to_ary))
+              0.5
+            else
+              0
+            end
           end
         end
         [[method_type, given || [], expected || []], score]
@@ -83,14 +125,24 @@ module KatakataIrb::Types
     intersect.call(InstanceType, &:klass)
   end
 
-  def self.type_from_object(object, max_level: 4)
+  def self.type_from_object(object)
+    case object
+    when Array, Hash, Module
+      type_from_object_recursive(object, max_level: 4)
+    else
+      klass = object.singleton_class rescue object.class
+      InstanceType.new klass
+    end
+  end
+
+  def self.type_from_object_recursive(object, max_level:)
     max_level -= 1
     sample_size = 1000
     case object
     when Array
       values = object.size > sample_size ? object.sample(sample_size) : object
       if max_level > 0
-        InstanceType.new Array, { Elem: UnionType[*values.map { type_from_object(_1, max_level: max_level) }] }
+        InstanceType.new Array, { Elem: UnionType[*values.map { type_from_object_recursive(_1, max_level: max_level) }] }
       else
         InstanceType.new Array, { Elem: UnionType[*values.map(&:class).uniq.map { InstanceType.new _1 }] }
       end
@@ -98,8 +150,8 @@ module KatakataIrb::Types
       keys = object.size > sample_size ? object.keys.sample(sample_size) : object.keys
       values = object.size > sample_size ? object.values.sample(sample_size) : object.values
       if max_level > 0
-        key_types = keys.map { type_from_object(_1, max_level: max_level) }
-        value_types = values.map { type_from_object(_1, max_level: max_level) }
+        key_types = keys.map { type_from_object_recursive(_1, max_level: max_level) }
+        value_types = values.map { type_from_object_recursive(_1, max_level: max_level) }
         InstanceType.new Hash, { K: UnionType[*key_types], V: UnionType[*value_types] }
       else
         key_types = keys.map(&:class).uniq.map { InstanceType.new _1 }
@@ -123,6 +175,11 @@ module KatakataIrb::Types
     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
@@ -136,6 +193,21 @@ module KatakataIrb::Types
     def all_methods() = @klass.instance_methods | @klass.private_instance_methods
     def constants() = []
     def types() = [self]
+    def nillable?() = (@klass == NilClass)
+    def nonnillable() = self
+    def inspect
+      case klass
+      when NilClass
+        'nil'
+      when TrueClass
+        'true'
+      when FalseClass
+        'false'
+      else
+        params_string = "[#{params.map { "#{_1}: #{_2.inspect}" }.join(', ')}]" unless params.empty?
+        "#{klass.name}#{params_string}"
+      end
+    end
   end
 
   class ProcType
@@ -150,11 +222,14 @@ module KatakataIrb::Types
     def all_methods() = Proc.instance_methods | Proc.private_instance_methods
     def constants() = []
     def types() = [self]
+    def nillable?() = (@klass == NilClass)
+    def nonnillable() = self
+    def inspect() = 'Proc'
   end
 
   NIL = InstanceType.new NilClass
   OBJECT = InstanceType.new Object
-  TRUE = InstanceType.new FalseClass
+  TRUE = InstanceType.new TrueClass
   FALSE = InstanceType.new FalseClass
   SYMBOL = InstanceType.new Symbol
   STRING = InstanceType.new String
@@ -203,6 +278,14 @@ module KatakataIrb::Types
       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?
@@ -217,15 +300,18 @@ module KatakataIrb::Types
     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.from_rbs_type(return_type, self_type, extra_vars = {})
     case return_type
     when RBS::Types::Bases::Self
       self_type
-    when RBS::Types::Bases::Void, RBS::Types::Bases::Bottom, RBS::Types::Bases::Nil
+    when RBS::Types::Bases::Bottom, RBS::Types::Bases::Nil
       NIL
-    when RBS::Types::Bases::Any
+    when RBS::Types::Bases::Any, RBS::Types::Bases::Void
       OBJECT
     when RBS::Types::Bases::Class
       self_type.transform do |type|
@@ -238,7 +324,7 @@ module KatakataIrb::Types
       end
       UnionType[*types]
     when RBS::Types::Bases::Bool
-      UnionType[TRUE, FALSE]
+      BOOLEAN
     when RBS::Types::Bases::Instance
       self_type.transform do |type|
         case type
@@ -286,7 +372,7 @@ module KatakataIrb::Types
       when :int
         INTEGER
       when :boolish
-        UnionType[TRUE, FALSE]
+        BOOLEAN
       when :string
         STRING
       else
@@ -332,6 +418,25 @@ module KatakataIrb::Types
       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

data/lib/katakata_irb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KatakataIrb
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end

data/sig/katakata_irb.rbs

@@ -1,4 +1,7 @@
 module KatakataIrb
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  module Completor
+    def self.analyze: (code: String, binding?: Binding) -> Array[Symbol | Object | String | true | false]?
+    def self.setup: () -> void
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katakata_irb
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-26 00:00:00.000000000 Z
+date: 2023-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb
@@ -56,6 +56,7 @@ files:
 - lib/katakata_irb.rb
 - lib/katakata_irb/completor.rb
 - lib/katakata_irb/nesting_parser.rb
+- lib/katakata_irb/scope.rb
 - lib/katakata_irb/type_simulator.rb
 - lib/katakata_irb/types.rb
 - lib/katakata_irb/version.rb
@@ -81,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.5
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: IRB with Typed Completion