katakata_irb 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 034055ed4a5fcf5bde6a1b86723c2963f82ace7c5b0411cd9a3e09fd734b10d2
-  data.tar.gz: 3e04438496f0241815cf7b674db57f7b644360520d9d829d75d5be61b63b78e5
+  metadata.gz: aceac4c5bece32a19a242c927326fa87814f34524368a90d1742ce9f66a055d4
+  data.tar.gz: 0c66cdde7506e1bace2fe342dae2104434ab0622cff5578c099e6e0f9179845c
 SHA512:
-  metadata.gz: 4b406ecd5c611cdc86220efa506c403dff220db4be5fb1bc1fab10eeb70931f0d7eaee8a45a702a6addb5de793e0c219562975d769fe31616305cd87fe4cfa4a
-  data.tar.gz: 147b09a36c68a66c917fff2157797d1124ec06e0333ee7cec26ef83b9d726c398bb83bbdce81f88c1706067ecc3f9bf99506d5706d3b22ccc3c8aa2ee6ce5cb1
+  metadata.gz: c806348785e27e8cd604ba978c18762826f087ed1406d0fc608d8334becb7b1b6d45f7e7a275cfef94455169719ab4e6ccfb0f4aa648c518a7f34915ed81961c
+  data.tar.gz: 26324135a3b7b153f093da98e0b3d7824aa6969b6135b26eb85da0eecdb4a3f04b8026946f898d2b1852315102d3101104f2fadc8bb0dbdd840b7856d10cd7fc

data/katakata_irb.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   # Uncomment to register a new dependency of your gem
   spec.add_dependency 'irb', '>= 1.4.0'
   spec.add_dependency 'reline', '>= 0.3.0'
-  spec.add_dependency 'prism', '>= 0.14.0'
+  spec.add_dependency 'prism', '>= 0.16.0'
   spec.add_dependency 'rbs'
 
   # For more information and examples about making a new gem, check out our

data/lib/katakata_irb/completor.rb

@@ -102,8 +102,6 @@ module KatakataIrb::Completor
             return KatakataIrb::Types.class_name_of(t.module_or_class)
           when KatakataIrb::Types::InstanceType
             return KatakataIrb::Types.class_name_of(t.klass)
-          when KatakataIrb::Types::ProcType
-            return 'Proc'
           end
         end
         nil
@@ -224,15 +222,18 @@ module KatakataIrb::Completor
     calculate_scope = -> { KatakataIrb::TypeAnalyzer.calculate_target_type_scope(binding, parents, target_node).last }
     calculate_type_scope = ->(node) { KatakataIrb::TypeAnalyzer.calculate_target_type_scope binding, [*parents, target_node], node }
 
-    if target_node.is_a?(Prism::StringNode) || target_node.is_a?(Prism::InterpolatedStringNode)
-      args_node = parents[-1]
-      call_node = parents[-2]
+    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
-      return unless call_node.is_a?(Prism::CallNode) && call_node.receiver.nil? && (call_node.message == 'require' || call_node.message == 'require_relative')
-      return [call_node.message.to_sym, name.rstrip]
-    end
 
-    case target_node
+      case call_node.name
+      when :require
+        [:require, name.rstrip]
+      when :require_relative
+        [:require_relative, name.rstrip]
+      end
     when Prism::SymbolNode
       if parents.last.is_a? Prism::BlockArgumentNode # method(&:target)
         receiver_type, _scope = calculate_type_scope.call target_node
@@ -287,8 +288,7 @@ module KatakataIrb::Completor
     )
     return [node] if location&.start_offset == position
 
-    node.child_nodes.each do |n|
-      next unless n.is_a? Prism::Node
+    node.compact_child_nodes.each do |n|
       match = find_target(n, position)
       next unless match
       match.unshift node

data/lib/katakata_irb/type_analyzer.rb

@@ -172,6 +172,8 @@ class KatakataIrb::TypeAnalyzer
         keys << evaluate(assoc.key, scope)
         values << evaluate(assoc.value, scope)
       when Prism::AssocSplatNode
+        next unless assoc.value # def f(**); {**}
+
         hash = evaluate assoc.value, scope
         unless hash.is_a?(KatakataIrb::Types::InstanceType) && hash.klass == Hash
           hash = method_call hash, :to_hash, [], nil, nil, scope
@@ -231,7 +233,7 @@ class KatakataIrb::TypeAnalyzer
 
 
   def evaluate_call_node(node, scope)
-    # TODO: return type of []=, field= when operator_loc.nil?
+    is_field_assign = node.name.match?(/[^<>=!\]]=\z/) || (node.name == :[]= && !node.call_operator)
     receiver_type = node.receiver ? evaluate(node.receiver, scope) : scope.self_type
     evaluate_method = lambda do |scope|
       args_types, kwargs_types, block_sym_node, has_block = evaluate_call_node_arguments node, scope
@@ -280,7 +282,12 @@ class KatakataIrb::TypeAnalyzer
       elsif has_block
         call_block_proc = ->(_block_args, _self_type) { KatakataIrb::Types::OBJECT }
       end
-      method_call receiver_type, node.name, args_types, kwargs_types, call_block_proc, scope
+      result = method_call receiver_type, node.name, args_types, kwargs_types, call_block_proc, scope
+      if is_field_assign
+        args_types.last || KatakataIrb::Types::NIL
+      else
+        result
+      end
     end
     if node.call_operator == '&.'
       result = scope.conditional { evaluate_method.call _1 }
@@ -314,8 +321,7 @@ class KatakataIrb::TypeAnalyzer
   def evaluate_index_or_write_node(node, scope) = evaluate_call_write(node, scope, :or, :[]=)
   def evaluate_call_write(node, scope, operator, write_name)
     receiver_type = evaluate node.receiver, scope
-    if node.respond_to? :arguments
-      # Prism >= 0.15.0, Call{Operator,And,Or}WriteNode does not have arguments
+    if write_name == :[]=
       args_types, kwargs_types, block_sym_node, has_block = evaluate_call_node_arguments node, scope
     else
       args_types = []
@@ -430,7 +436,7 @@ class KatakataIrb::TypeAnalyzer
     end
     block_scope.merge_jumps
     scope.update block_scope
-    KatakataIrb::Types::ProcType.new
+    KatakataIrb::Types::PROC
   end
 
   def evaluate_reference_write(node, scope)
@@ -457,7 +463,6 @@ class KatakataIrb::TypeAnalyzer
       elsif node.value
         evaluate node.value, scope
       else
-        # For syntax invalid code like `(*a).b`
         KatakataIrb::Types::NIL
       end
     )
@@ -748,6 +753,12 @@ class KatakataIrb::TypeAnalyzer
     KatakataIrb::Types::NIL
   end
 
+  def evaluate_splat_node(node, scope)
+    # Raw SplatNode, incomplete code like `*a.`
+    evaluate_multi_write_receiver node.expression, scope, nil if node.expression
+    KatakataIrb::Types::NIL
+  end
+
   def evaluate_implicit_node(node, scope)
     evaluate node.value, scope
   end
@@ -784,7 +795,7 @@ class KatakataIrb::TypeAnalyzer
   def evaluate_call_node_arguments(call_node, scope)
     # call_node.arguments is Prism::ArgumentsNode
     arguments = call_node.arguments&.arguments&.dup || []
-    block_arg = call_node.block.expression if call_node.respond_to?(:block) && call_node.block.is_a?(Prism::BlockArgumentNode)
+    block_arg = call_node.block.expression if call_node.block.is_a?(Prism::BlockArgumentNode)
     kwargs = arguments.pop.elements if arguments.last.is_a?(Prism::KeywordHashNode)
     args_types = arguments.map do |arg|
       case arg
@@ -792,7 +803,7 @@ class KatakataIrb::TypeAnalyzer
         # `f(a, ...)` treat like splat
         nil
       when Prism::SplatNode
-        evaluate arg.expression, scope
+        evaluate arg.expression, scope if arg.expression
         nil # TODO: splat
       else
         evaluate arg, scope
@@ -810,7 +821,7 @@ class KatakataIrb::TypeAnalyzer
             nil
           end
         when Prism::AssocSplatNode
-          evaluate arg.value, scope
+          evaluate arg.value, scope if arg.value
           nil
         end
       end.compact.to_h
@@ -833,17 +844,18 @@ class KatakataIrb::TypeAnalyzer
   end
 
   def assign_required_parameter(node, value, scope)
-    case node
-    when Prism::RequiredParameterNode
+    case node.type
+    when :required_parameter_node
       scope[node.name.to_s] = value || KatakataIrb::Types::OBJECT
-    when Prism::RequiredDestructuredParameterNode
-      values = value ? sized_splat(value, :to_ary, node.parameters.size) : []
-      node.parameters.zip values do |n, v|
+    when :multi_target_node
+      parameters = [*node.lefts, *node.rest, *node.rights]
+      values = value ? sized_splat(value, :to_ary, parameters.size) : []
+      parameters.zip values do |n, v|
         assign_required_parameter n, v, scope
       end
-    when Prism::SplatNode
+    when :splat_node
       splat_value = value ? KatakataIrb::Types.array_of(value) : KatakataIrb::Types::ARRAY
-      assign_required_parameter node.expression, splat_value, scope
+      assign_required_parameter node.expression, splat_value, scope if node.expression
     end
   end
 
@@ -881,7 +893,7 @@ class KatakataIrb::TypeAnalyzer
     args = sized_splat(args.first, :to_ary, size) if size >= 2 && args.size == 1
     reqs = args.shift node.requireds.size
     if node.rest
-      # node.rest.class is Prism::RestParameterNode
+      # node.rest is Prism::RestParameterNode
       posts = []
       opts = args.shift node.optionals.size
       rest = args
@@ -907,10 +919,12 @@ class KatakataIrb::TypeAnalyzer
       scope[node.rest.name.to_s] = KatakataIrb::Types.array_of(*rest)
     end
     node.keywords.each do |n|
-      # n is Prism::KeywordParameterNode
+      # n is Prism::KeywordParameterNode (prism = 0.16.0)
+      # n is Prism::RequiredKeywordParameterNode | Prism::OptionalKeywordParameterNode (prism > 0.16.0)
       name = n.name.to_s.delete(':')
       values = [kwargs.delete(name)]
-      values << evaluate(n.value, scope) if n.value
+      # `respond_to?` is for prism > 0.16.0, `&& n.value` is for prism = 0.16.0
+      values << evaluate(n.value, scope) if n.respond_to?(:value) && n.value
       scope[name] = KatakataIrb::Types::UnionType[*values.compact]
     end
     # node.keyword_rest is Prism::KeywordRestParameterNode or Prism::ForwardingParameterNode or Prism::NoKeywordsParameterNode
@@ -927,13 +941,7 @@ class KatakataIrb::TypeAnalyzer
     return if numbered_parameters.empty?
     max_num = numbered_parameters.map { _1[1].to_i }.max
     if max_num == 1
-      if args.size == 0
-        scope['_1'] = KatakataIrb::Types::NIL
-      elsif args.size == 1
-        scope['_1'] = args.first
-      else
-        scope['_1'] = KatakataIrb::Types.array_of(*args)
-      end
+      scope['_1'] = args.first || KatakataIrb::Types::NIL
     else
       args = sized_splat(args.first, :to_ary, max_num) if args.size == 1
       numbered_parameters.each do |name|
@@ -976,7 +984,10 @@ class KatakataIrb::TypeAnalyzer
       KatakataIrb::Types::ARRAY
     when Prism::HashPatternNode
       # TODO
-      pattern.assocs.each { evaluate_match_pattern KatakataIrb::Types::OBJECT, _1, scope }
+      pattern.elements.each { evaluate_match_pattern KatakataIrb::Types::OBJECT, _1, scope }
+      if pattern.respond_to?(:rest) && pattern.rest
+        evaluate_match_pattern KatakataIrb::Types::OBJECT, pattern.rest, scope
+      end
       KatakataIrb::Types::HASH
     when Prism::AssocNode
       evaluate_match_pattern value, pattern.value, scope if pattern.value
@@ -1022,7 +1033,7 @@ class KatakataIrb::TypeAnalyzer
     when Prism::CallNode
       evaluated_receivers&.[](node.receiver) || evaluate(node.receiver, scope) if node.receiver
     when Prism::SplatNode
-      evaluate_write node.expression, KatakataIrb::Types.array_of(value), scope, evaluated_receivers
+      evaluate_write node.expression, KatakataIrb::Types.array_of(value), scope, evaluated_receivers if node.expression
     when Prism::LocalVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::ConstantTargetNode
       scope[node.name.to_s] = value
     when Prism::ConstantPathTargetNode
@@ -1033,20 +1044,15 @@ class KatakataIrb::TypeAnalyzer
   end
 
   def evaluate_multi_write(node, values, scope, evaluated_receivers)
-    values = sized_splat values, :to_ary, node.targets.size unless values.is_a? Array
-    splat_index = node.targets.find_index { _1.is_a? Prism::SplatNode }
-    if splat_index
-      pre_targets = node.targets[0...splat_index]
-      splat_target = node.targets[splat_index]
-      post_targets = node.targets[splat_index + 1..]
-      pre_values = values.shift pre_targets.size
-      post_values = values.pop post_targets.size
-      splat_value = KatakataIrb::Types::UnionType[*values]
-      zips = pre_targets.zip(pre_values) + [[splat_target, splat_value]] + post_targets.zip(post_values)
-    else
-      zips = node.targets.zip(values)
-    end
-    zips.each do |target, value|
+    pre_targets = node.lefts
+    splat_target = node.rest
+    post_targets = node.rights
+    size = pre_targets.size + (splat_target ? 1 : 0) + post_targets.size
+    values = values.is_a?(Array) ? values.dup : sized_splat(values, :to_ary, size)
+    pre_pairs = pre_targets.zip(values.shift(pre_targets.size))
+    post_pairs = post_targets.zip(values.pop(post_targets.size))
+    splat_pairs = splat_target ? [[splat_target, KatakataIrb::Types::UnionType[*values]]] : []
+    (pre_pairs + splat_pairs + post_pairs).each do |target, value|
       evaluate_write target, value || KatakataIrb::Types::NIL, scope, evaluated_receivers
     end
   end
@@ -1054,7 +1060,8 @@ class KatakataIrb::TypeAnalyzer
   def evaluate_multi_write_receiver(node, scope, evaluated_receivers)
     case node
     when Prism::MultiWriteNode, Prism::MultiTargetNode
-      node.targets.each { evaluate_multi_write_receiver _1, scope, evaluated_receivers }
+      targets = [*node.lefts, *node.rest, *node.rights]
+      targets.each { evaluate_multi_write_receiver _1, scope, evaluated_receivers }
     when Prism::CallNode
       if node.receiver
         receiver = evaluate(node.receiver, scope)
@@ -1077,13 +1084,15 @@ class KatakataIrb::TypeAnalyzer
   def evaluate_list_splat_items(list, scope)
     items = list.flat_map do |node|
       if node.is_a? Prism::SplatNode
+        next unless node.expression # def f(*); [*]
+
         splat = evaluate node.expression, scope
         array_elem, non_array = partition_to_array splat.nonnillable, :to_a
         [*array_elem, *non_array]
       else
         evaluate node, scope
       end
-    end.uniq
+    end.compact.uniq
     KatakataIrb::Types::UnionType[*items]
   end
 

data/lib/katakata_irb/types.rb

@@ -47,8 +47,6 @@ module KatakataIrb::Types
   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
@@ -70,8 +68,6 @@ module KatakataIrb::Types
 
     receivers = type.types.map do |t|
       case t
-      in ProcType
-        [t, Proc, false]
       in SingletonType
         [t, t.module_or_class, true]
       in InstanceType
@@ -125,7 +121,6 @@ module KatakataIrb::Types
   def self.intersect?(a, b)
     atypes = a.types.group_by(&:class)
     btypes = b.types.group_by(&:class)
-    return true if atypes[ProcType] && btypes[ProcType]
     if atypes[SingletonType] && btypes[SingletonType]
       aa, bb = [atypes, btypes].map {|types| types[SingletonType].map(&:module_or_class) }
       return true if (aa & bb).any?
@@ -233,23 +228,6 @@ module KatakataIrb::Types
     end
   end
 
-  class ProcType
-    attr_reader :params, :kwparams, :return_type
-    def initialize(params = [], kwparams = {}, return_type = NIL)
-      @params = params
-      @kwparams = kwparams
-      @return_type = return_type
-    end
-    def transform() = yield(self)
-    def methods() = Proc.instance_methods
-    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 TrueClass
@@ -266,7 +244,7 @@ module KatakataIrb::Types
   HASH = InstanceType.new Hash
   CLASS = InstanceType.new Class
   MODULE = InstanceType.new Module
-  PROC = ProcType.new
+  PROC = InstanceType.new Proc
 
   class UnionType
     attr_reader :types
@@ -275,7 +253,6 @@ module KatakataIrb::Types
       @types = []
       singletons = []
       instances = {}
-      procs = []
       collect = -> type do
         case type
         in UnionType
@@ -287,12 +264,10 @@ module KatakataIrb::Types
           end
         in SingletonType
           singletons << type
-        in ProcType
-          procs << type
         end
       end
       types.each(&collect)
-      @types = procs.uniq + singletons.uniq + instances.map do |klass, params|
+      @types = singletons.uniq + instances.map do |klass, params|
         InstanceType.new(klass, params.transform_values { |v| UnionType[*v] })
       end
     end
@@ -364,7 +339,7 @@ module KatakataIrb::Types
     when RBS::Types::Union
       UnionType[*return_type.types.map { from_rbs_type _1, self_type, extra_vars }]
     when RBS::Types::Proc
-      InstanceType.new 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

data/lib/katakata_irb/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katakata_irb
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-18 00:00:00.000000000 Z
+date: 2023-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.16.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.16.0
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement