katakata_irb 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07b0eb3288cc4eec15c83de9bd27948379bca2c1dfa233104cba59dff6826c7c
-  data.tar.gz: 20d4feb90c4df7e10554e045addfb242af50205dd0b187635a81ac3bc5b073b2
+  metadata.gz: 4b1d8be38e882e8b24f1f3add323f4160e36d8300d9ae1d9e22572a6c7c272ad
+  data.tar.gz: a2918483fbfd537fcfaa7fd6423727ec3a9b458da86329b803fc8f48dbe565d7
 SHA512:
-  metadata.gz: 7a376d7deb729f3a2e2f3b18041e89606d668e331ece73c32d5b7ae9ff6b8d87bffa89f4ab3d1dc66c8354b3af2ad733bee211868e01bd8814055f3cc72fe83b
-  data.tar.gz: 50eaa7061da8609623f1fccc5d0fbe12685f888d7a565eede06e19993b435aa766ce6458668fa787369bef62ce5601b6dd9c4118fa534457c89341881367722d
+  metadata.gz: 7c9437f1bd885f507bac318bfef116f3c0aa86c606a694167b4436eb3e48e7b51789d9fcb8387155ec20cf28166fdb3fe0f162fbc9777f57758d74f368fcfad7
+  data.tar.gz: b4512a603b807f8566dc5fb0d60cb0185e384b2c0129c6a91dceecbba4abd093df8d8a07ad9a817b18279fec7f9dfc6011560128b68e5e55e177ca9a7ae3a5dc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    katakata_irb (0.1.0)
+    katakata_irb (0.1.1)
       rbs
 
 GEM

data/bin/console

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 require_relative '../lib/katakata_irb'
 require_relative '../lib/katakata_irb/reline_patch'
-KatakataIrb::RelinePatch.require_patched_reline
 KatakataIrb.log_output = STDERR
+KatakataIrb::RelinePatch.require_patched_reline
 require 'bundler/setup'
 require 'katakata_irb'
 require 'katakata_irb/ruby_lex_patch'

data/exe/kirb

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+require_relative '../lib/katakata_irb'
+KatakataIrb.log_output = STDERR if ARGV.delete '--debug-output'
 unless ARGV.delete '--without-patch'
   require_relative '../lib/katakata_irb/reline_patch'
   KatakataIrb::RelinePatch.require_patched_reline
@@ -6,5 +8,4 @@ unless ARGV.delete '--without-patch'
   KatakataIrb::RubyLexPatch.patch_to_ruby_lex
 end
 require 'katakata_irb'
-KatakataIrb.log_output = STDERR if ARGV.delete '--debug-output'
 KatakataIrb.repl

data/lib/katakata_irb/completor.rb

@@ -61,25 +61,26 @@ module KatakataIrb::Completor
     code = lvars_code + code
     tokens = RubyLex.ripper_lex_without_warning code
     tokens = KatakataIrb::TRex.interpolate_ripper_ignored_tokens code, tokens
-    last_opens, unclosed_heredocs = KatakataIrb::TRex.parse(tokens)
-    closings = (last_opens + unclosed_heredocs).map do |t,|
+    last_opens = KatakataIrb::TRex.parse(tokens)
+    closings = last_opens.map do |t|
       case t.tok
       when /\A%.[<>]\z/
-        '>'
+        $/ + '>'
       when '{', '#{', /\A%.?[{}]\z/
-        '}'
+        $/ + '}'
       when '(', /\A%.?[()]\z/
+        # do not insert \n before closing paren. workaround to avoid syntax error of "a in ^(b\n)"
         ')'
       when '[', /\A%.?[\[\]]\z/
-        ']'
+        $/ + ']'
       when /\A%.?(.)\z/
         $1
       when '"', "'", '/', '`'
         t.tok
-      when /\A<<(?:"(?<s>.+)"|'(?<s>.+)'|(?<s>.+))/
-        $3
+      when /\A<<[~-]?(?:"(?<s>.+)"|'(?<s>.+)'|(?<s>.+))/
+        $/ + ($1 || $2 || $3) + $/
       else
-        'end'
+        $/ + 'end'
       end
     end
 
@@ -107,8 +108,7 @@ module KatakataIrb::Completor
       return
     end
 
-    closings = $/ + closings.reverse.join($/)
-    sexp = Ripper.sexp code + suffix + closings
+    sexp = Ripper.sexp code + suffix + closings.reverse.join
     lines = code.lines
     line_no = lines.size
     col = lines.last.bytesize
@@ -117,14 +117,14 @@ module KatakataIrb::Completor
       col = 0
     end
 
-    if sexp in [:program, [lvars_exp, *rest_statements]]
+    if sexp in [:program, [_lvars_exp, *rest_statements]]
       sexp = [:program, rest_statements]
     end
 
     *parents, expression, target = find_target sexp, line_no, col
     in_class_module = parents&.any? { _1 in [:class | :module,] }
     icvar_available = !in_class_module
-    return unless target in [type, String, [Integer, Integer]]
+    return unless target in [_type, String, [Integer, Integer]]
     if target in [:@ivar,]
       return [:ivar, name] if icvar_available
     elsif target in [:@cvar,]

data/lib/katakata_irb/reline_patch.rb

@@ -16,14 +16,17 @@ module KatakataIrb::RelinePatch
         diff.split(/^@@.+\n/).drop(1).map(&:lines).each do |lines|
           target = lines.reject { _1[0] == '+' }.map { _1[1..] }.join
           replace = lines.reject { _1[0] == '-' }.map { _1[1..] }.join
-          raise unless code.include? target
-          code.sub! target, replace
+          if code.include? target
+            code = code.sub target, replace
+          elsif !code.include?(replace)
+            raise
+          end
         end
         current_patched[path] = code
       end
       patched.update current_patched
     rescue
-      puts "Failed to apply katakata_irb/reline_patches/#{patch_name}.patch to reline"
+      KatakataIrb.log_puts "Failed to apply katakata_irb/reline_patches/#{patch_name}.patch to reline"
     end
 
     RelinePatchIseqLoader.define_method :load_iseq do |fname|

data/lib/katakata_irb/ruby_lex_patch.rb

@@ -3,7 +3,7 @@ require_relative 'trex'
 
 module KatakataIrb::RubyLexPatch
   def self.patch_to_ruby_lex
-    (RubyLex.instance_methods(false) - [:initialize_input, :set_prompt, :process_continue, :check_code_block]).each { RubyLex.remove_method _1 }
+    (RubyLex.instance_methods(false) - [:set_prompt, :process_continue, :check_code_block]).each { RubyLex.remove_method _1 }
     RubyLex.prepend self
   end
 
@@ -12,20 +12,20 @@ module KatakataIrb::RubyLexPatch
     KatakataIrb::TRex.interpolate_ripper_ignored_tokens(code, incomplete_tokens)
   end
 
-  def calc_nesting_depth(tokens)
+  def calc_nesting_depth(opens)
     indent_level = 0
     nesting_level = 0
-    tokens.each_with_index do |t, index|
+    opens.each_with_index do |t, index|
       case t.event
       when :on_heredoc_beg
-        if tokens[index + 1]&.event != :on_heredoc_beg
+        if opens[index + 1]&.event != :on_heredoc_beg
           if t.tok.start_with?('<<~')
             indent_level += 1
           else
             indent_level = 0
           end
         end
-      when :on_tstring_beg, :on_regexp_beg
+      when :on_tstring_beg, :on_regexp_beg, :on_symbeg
         indent_level += 1 if t.tok[0] == '%'
       when :on_embdoc_beg
         indent_level = 0
@@ -38,18 +38,18 @@ module KatakataIrb::RubyLexPatch
   end
 
   def process_indent_level(tokens)
-    opens, heredocs = KatakataIrb::TRex.parse(tokens)
-    indent, _nesting = calc_nesting_depth(opens.map(&:first) + heredocs)
+    opens = KatakataIrb::TRex.parse(tokens)
+    indent, _nesting = calc_nesting_depth(opens)
     indent * 2
   end
 
   def check_corresponding_token_depth(tokens, line_index)
-    lines, = KatakataIrb::TRex.parse_line(tokens)
-    result = lines[line_index]
+    line_results = KatakataIrb::TRex.parse_line(tokens)
+    result = line_results[line_index]
     return unless result
     _tokens, prev, opens, min_depth = result
-    depth, = calc_nesting_depth(opens.take(min_depth).map(&:first))
-    prev_depth, = calc_nesting_depth(prev.map(&:first))
+    depth, = calc_nesting_depth(opens.take(min_depth))
+    prev_depth, = calc_nesting_depth(prev)
     depth * 2 if depth < prev_depth
   end
 
@@ -62,9 +62,9 @@ module KatakataIrb::RubyLexPatch
       ?'
     when ?", /^<</, /^%.$/, /^%Q.$/
       ?"
-    when ":'", ':"', ':', /^%s$/
+    when ":'", ':"', ':', /^%s.$/
       ':'
-    when /^%[iwIW]$/
+    when /^%[iwIW].$/
       ']'
     when '/', /^%r.$/
       '/'
@@ -72,14 +72,28 @@ module KatakataIrb::RubyLexPatch
   end
 
   def check_termination_in_prev_line(code, context: nil)
-    *lines, last_line = code.lines
-    last_line if lines.any? && check_termination(lines.join, context: context)
+    tokens = self.class.ripper_lex_without_warning(code, context: context)
+    last_newline_index = tokens.rindex { |t| t.tok.include?("\n") }
+    index = (0...last_newline_index).reverse_each.find { |i| tokens[i].tok.include?("\n") }
+    return false unless index
+
+    last_line_tokens = tokens[(index + 1)..(tokens.size - 1)]
+    first_token = last_line_tokens.find do |t|
+      ![:on_sp, :on_ignored_sp, :on_comment].include?(t.event)
+    end
+
+    if first_token && first_token.state != Ripper::EXPR_DOT
+      tokens_without_last_line = tokens[0..index]
+      if check_termination(tokens_without_last_line)
+        return last_line_tokens.map(&:tok).join
+      end
+    end
+    false
   end
 
-  def check_termination(code, context: nil)
-    tokens = KatakataIrb::RubyLexPatch.complete_tokens(code, context: context)
-    opens, heredocs = KatakataIrb::TRex.parse(tokens)
-    opens.empty? && heredocs.empty? && !process_continue(tokens)
+  def check_termination(tokens)
+    opens = KatakataIrb::TRex.parse(tokens)
+    opens.empty? && !process_continue(tokens)
   end
 
   def set_input(io, p = nil, context: nil, &block)
@@ -99,7 +113,8 @@ module KatakataIrb::RubyLexPatch
             false
           end
         else
-          check_termination(code, context: context)
+          tokens = KatakataIrb::RubyLexPatch.complete_tokens(code, context: context)
+          check_termination(tokens)
         end
       end
     end
@@ -108,10 +123,14 @@ module KatakataIrb::RubyLexPatch
         lines << '' if lines.empty?
         code = lines.map{ |l| l + "\n" }.join
         tokens = KatakataIrb::RubyLexPatch.complete_tokens code, context: context
-        lines, _unclosed_heredocs = KatakataIrb::TRex.parse_line(tokens)
+        line_results = KatakataIrb::TRex.parse_line(tokens)
         continue = false
-        lines.map.with_index do |(line, _prev_opens, next_opens), line_num_offset|
-          unless (c = process_continue(line.map(&:first))).nil?
+        tokens_until_line = []
+        line_results.map.with_index do |(line_tokens, _prev_opens, next_opens), line_num_offset|
+          line_tokens.each do |token, _s|
+            tokens_until_line << token if token != tokens_until_line.last
+          end
+          unless (c = process_continue(tokens_until_line)).nil?
             continue = c
           end
           prompt next_opens, continue, line_num_offset
@@ -146,8 +165,8 @@ module KatakataIrb::RubyLexPatch
   end
 
   def prompt(opens, continue, line_num_offset)
-    ltype = ltype_from_open_tokens opens.map(&:first)
-    _indent, nesting_level = calc_nesting_depth opens.map(&:first)
+    ltype = ltype_from_open_tokens(opens)
+    _indent, nesting_level = calc_nesting_depth(opens)
     @prompt.call(ltype, nesting_level, opens.any? || continue, @line_no + line_num_offset)
   end
 
@@ -166,10 +185,13 @@ module KatakataIrb::RubyLexPatch
       store_prompt_to_irb [], false, 0
       loop do
         l = @input.call
-        next if l.nil?
+        unless l
+          return if line.empty?
+          next
+        end
         line << l
         tokens = KatakataIrb::RubyLexPatch.complete_tokens(line, context: context)
-        _line, _prev_opens, next_opens = KatakataIrb::TRex.parse_line(tokens).first.last
+        _line_tokens, _prev_opens, next_opens = KatakataIrb::TRex.parse_line(tokens).last
         return line if next_opens.empty?
         line_offset += 1
         store_prompt_to_irb next_opens, true, line_offset
@@ -178,7 +200,6 @@ module KatakataIrb::RubyLexPatch
   end
 
   def each_top_level_statement(context = nil)
-    initialize_input
     loop do
       begin
         line = readmultiline(context)
@@ -188,9 +209,7 @@ module KatakataIrb::RubyLexPatch
           yield line, @line_no
         end
         @line_no += line.count("\n")
-        raise RubyLex::TerminateLineInput if @io.eof?
       rescue RubyLex::TerminateLineInput
-        initialize_input
       end
     end
   end

data/lib/katakata_irb/trex.rb

@@ -176,7 +176,7 @@ module KatakataIrb::TRex
       end
       yield t, index, opens if block_given?
     end
-    [opens, pending_heredocs.reverse]
+    opens.map(&:first) + pending_heredocs.reverse
   end
 
   def self.parse_line(tokens)
@@ -184,14 +184,14 @@ module KatakataIrb::TRex
     prev_opens = []
     min_depth = 0
     output = []
-    last_opens, unclosed_heredocs = KatakataIrb::TRex.parse(tokens) do |t, _index, opens|
+    last_opens = KatakataIrb::TRex.parse(tokens) do |t, _index, opens|
       depth = t == opens.last&.first ? opens.size - 1 : opens.size
       min_depth = depth if depth < min_depth
       if t.tok.include? "\n"
         t.tok.each_line do |line|
           line_tokens << [t, line]
           next if line[-1] != "\n"
-          next_opens = opens.dup
+          next_opens = opens.map(&:first)
           output << [line_tokens, prev_opens, next_opens, min_depth]
           prev_opens = next_opens
           min_depth = prev_opens.size
@@ -202,6 +202,6 @@ module KatakataIrb::TRex
       end
     end
     output << [line_tokens, prev_opens, last_opens, min_depth] if line_tokens.any?
-    [output, unclosed_heredocs]
+    output
   end
 end

data/lib/katakata_irb/type_simulator.rb

@@ -104,12 +104,18 @@ class KatakataIrb::TypeSimulator
       @terminated
     end
 
-    def terminate_with(type)
+    def terminate_with(type, value)
+      return if terminated?
+      self[type] = value
+      store_jump type
+      terminate
+    end
+
+    def store_jump(type)
       scopes = ancestors.select(&:mutable?)
       scope = scopes.find { _1.has_own? type } || scopes.last
       index = scopes.index scope
       scope.jump_branches << scopes.drop(index).map(&:branch_table_clone)
-      terminate
     end
 
     def terminate
@@ -132,8 +138,7 @@ class KatakataIrb::TypeSimulator
     end
 
     def []=(name, type)
-      # return if terminated?
-      if @passthrough && !BaseScope.type_by_name(name) == :internal
+      if @passthrough && BaseScope.type_by_name(name) != :internal
         @parent[name] = type
       elsif trace?(name) && @parent.mutable? && !@tables.any? { _1.key? name } && @parent.has?(name)
         @parent[name] = type
@@ -189,6 +194,10 @@ class KatakataIrb::TypeSimulator
       run_branches(block, -> {}).first || KatakataIrb::Types::NIL
     end
 
+    def never(&block)
+      branch(&block)
+    end
+
     def run_branches(*blocks)
       results = blocks.map { branch(&_1) }.reject(&:last)
       merge results.map { _2 }
@@ -263,6 +272,8 @@ class KatakataIrb::TypeSimulator
   BREAK_RESULT = '%break'
   NEXT_RESULT = '%next'
   RETURN_RESULT = '%return'
+  PATTERNMATCH_BREAK = '%match'
+  RAISE_BREAK = '%raise'
 
   def initialize(dig_targets)
     @dig_targets = dig_targets
@@ -279,8 +290,8 @@ class KatakataIrb::TypeSimulator
     in [:program, statements]
       statements.map { simulate_evaluate _1, scope }.last
     in [:def | :defs,]
-      sexp in [:def, method_name_exp, params, body_stmt]
-      sexp in [:defs, receiver_exp, dot_exp, method_name_exp, params, body_stmt]
+      sexp in [:def, _method_name_exp, params, body_stmt]
+      sexp in [:defs, receiver_exp, _dot_exp, _method_name_exp, params, body_stmt]
       if receiver_exp
         receiver_exp in  [:paren, receiver_exp]
         self_type = simulate_evaluate receiver_exp, scope
@@ -443,6 +454,10 @@ class KatakataIrb::TypeSimulator
         return scope[name]
       end
       receiver, method, args, kwargs, block, conditional = retrieve_method_call sexp
+      if receiver.nil? && method == 'raise'
+        scope.terminate_with RAISE_BREAK, KatakataIrb::Types::TRUE
+        return KatakataIrb::Types::NIL
+      end
       receiver_type = receiver ? simulate_evaluate(receiver, scope) : scope.self_type
       evaluate_method = lambda do
         args_type = args.map do |arg|
@@ -486,6 +501,7 @@ class KatakataIrb::TypeSimulator
               [KatakataIrb::Types::UnionType[result, *nexts], breaks]
             end
           else
+            call_block_proc = ->(_block_args) { KatakataIrb::Types::OBJECT }
             simulate_evaluate block, scope
           end
         end
@@ -584,33 +600,37 @@ class KatakataIrb::TypeSimulator
       inner_scope = Scope.new scope, { BREAK_RESULT => nil }, passthrough: true
       simulate_evaluate cond, inner_scope
       scope.conditional { statements.each { simulate_evaluate _1, inner_scope } }
-      breaks = inner_scope[BREAK_RESULT]
       inner_scope.merge_jumps
+      breaks = inner_scope[BREAK_RESULT]
       breaks ? KatakataIrb::Types::UnionType[breaks, KatakataIrb::Types::NIL] : KatakataIrb::Types::NIL
     in [:while_mod | :until_mod, cond, statement]
-      simulate_evaluate cond, scope
-      scope.conditional { simulate_evaluate statement, scope }
-      KatakataIrb::Types::NIL
+      inner_scope = Scope.new scope, { BREAK_RESULT => nil }, passthrough: true
+      simulate_evaluate cond, inner_scope
+      scope.conditional { simulate_evaluate statement, inner_scope }
+      inner_scope.merge_jumps
+      breaks = inner_scope[BREAK_RESULT]
+      breaks ? KatakataIrb::Types::UnionType[breaks, KatakataIrb::Types::NIL] : KatakataIrb::Types::NIL
     in [:break | :next | :return => jump_type, value]
       internal_key = jump_type == :break ? BREAK_RESULT : jump_type == :next ? NEXT_RESULT : RETURN_RESULT
       if value.empty?
-        scope[internal_key] = KatakataIrb::Types::NIL
+        jump_value = KatakataIrb::Types::NIL
       else
         values, kw = evaluate_mrhs value, scope
         values << kw if kw
-        scope[internal_key] = values.size == 1 ? values.first : KatakataIrb::Types::InstanceType.new(Array, Elem: KatakataIrb::Types::UnionType[*values])
+        jump_value = values.size == 1 ? values.first : KatakataIrb::Types::InstanceType.new(Array, Elem: KatakataIrb::Types::UnionType[*values])
       end
-      scope.terminate_with internal_key
+      scope.terminate_with internal_key, jump_value
       KatakataIrb::Types::NIL
     in [:return0]
-      scope[RETURN_RESULT] = KatakataIrb::Types::NIL
-      scope.terminate_with RETURN_RESULT
+      scope.terminate_with RETURN_RESULT, KatakataIrb::Types::NIL
       KatakataIrb::Types::NIL
     in [:yield, args]
       evaluate_mrhs args, scope
       KatakataIrb::Types::OBJECT
     in [:yield0]
       KatakataIrb::Types::OBJECT
+    in [:redo | :retry]
+      scope.terminate
     in [:super, args]
       args, kwargs, _block = retrieve_method_args args
       args.each do |arg|
@@ -623,7 +643,9 @@ class KatakataIrb::TypeSimulator
       simulate_evaluate body_stmt, scope
     in [:bodystmt, statements, rescue_stmt, _unknown, ensure_stmt]
       statements = [statements] if statements in [Symbol,] # oneliner-def body
-      return_type = statements.map { simulate_evaluate _1, scope }.last
+      rescue_scope = Scope.new scope, { RAISE_BREAK => nil }, passthrough: true if rescue_stmt
+      return_type = statements.map { simulate_evaluate _1, rescue_scope || scope }.last
+      rescue_scope&.merge_jumps
       if rescue_stmt
         return_type = KatakataIrb::Types::UnionType[return_type, scope.conditional { simulate_evaluate rescue_stmt, scope }]
       end
@@ -647,7 +669,9 @@ class KatakataIrb::TypeSimulator
       end
       return_type
     in [:rescue_mod, statement1, statement2]
-      a = simulate_evaluate statement1, scope
+      rescue_scope = Scope.new scope, { RAISE_BREAK => nil }, passthrough: true
+      a = simulate_evaluate statement1, rescue_scope
+      rescue_scope.merge_jumps
       b = scope.conditional { simulate_evaluate statement2, scope }
       KatakataIrb::Types::UnionType[a, b]
     in [:module, module_stmt, body_stmt]
@@ -675,39 +699,48 @@ class KatakataIrb::TypeSimulator
       extract_param_names(params).each { scope[_1] = KatakataIrb::Types::NIL }
       response = simulate_call enum, :first, [], nil, nil
       evaluate_assign_params params, [response], scope
+      inner_scope = Scope.new scope, { BREAK_RESULT => nil }, passthrough: true
       scope.conditional do
-        statements.each { simulate_evaluate _1, scope }
+        statements.each { simulate_evaluate _1, inner_scope }
       end
-      enum
-    in [:in | :when => mode, pattern, if_statements, else_statement]
-      if mode == :in
-        if_match = -> { match_pattern case_target, pattern, scope }
-        else_match = -> { scope.conditional { if_match.call } }
-      else
-        eval_pattern = lambda do |pattern, *rest|
-          simulate_evaluate pattern, scope
-          scope.conditional { eval_pattern.call(*rest) } if rest.any?
-        end
-        if_match = -> { eval_pattern.call(*pattern) }
-        else_match = -> { pattern.each { simulate_evaluate _1, scope } }
+      inner_scope.merge_jumps
+      breaks = inner_scope[BREAK_RESULT]
+      breaks ? KatakataIrb::Types::UnionType[breaks, enum] : enum
+    in [:when, pattern, if_statements, else_statement]
+      eval_pattern = lambda do |pattern, *rest|
+        simulate_evaluate pattern, scope
+        scope.conditional { eval_pattern.call(*rest) } if rest.any?
       end
       if_branch = lambda do
-        if_match.call
+        eval_pattern.call(*pattern)
         if_statements.map { simulate_evaluate _1, scope }.last
       end
       else_branch = lambda do
-        else_match.call
+        pattern.each { simulate_evaluate _1, scope }
         simulate_evaluate(else_statement, scope, case_target:)
       end
       if if_statements && else_statement
         KatakataIrb::Types::UnionType[*scope.run_branches(if_branch, else_branch)]
-      elsif if_statements
-        KatakataIrb::Types::UnionType[scope.conditional { if_branch.call }, KatakataIrb::Types::NIL]
-      elsif else_statement
-        KatakataIrb::Types::UnionType[scope.conditional { else_branch.call }, KatakataIrb::Types::NIL]
       else
-        KatakataIrb::Types::NIL
+        KatakataIrb::Types::UnionType[scope.conditional { (if_branch || else_branch).call }, KatakataIrb::Types::NIL]
       end
+    in [:in, [:var_field, [:@ident, name,]], if_statements, else_statement]
+      scope.never { simulate_evaluate else_statement, scope } if else_statement
+      scope[name] = case_target || KatakataIrb::Types::OBJECT
+      if_statements ? if_statements.map { simulate_evaluate _1, scope }.last : KatakataIrb::Types::NIL
+    in [:in, pattern, if_statements, else_statement]
+      pattern_scope = Scope.new(scope, { PATTERNMATCH_BREAK => nil }, passthrough: true)
+      results = scope.run_branches(
+        -> {
+          match_pattern case_target, pattern, pattern_scope
+          if_statements ? if_statements.map { simulate_evaluate _1, scope }.last : KatakataIrb::Types::NIL
+        },
+        -> {
+          pattern_scope.merge_jumps
+          else_statement ? simulate_evaluate(else_statement, scope, case_target:) : KatakataIrb::Types::NIL
+        }
+      )
+      KatakataIrb::Types::UnionType[*results]
     in [:case, target_exp, match_exp]
       target = simulate_evaluate target_exp, scope
       simulate_evaluate match_exp, scope, case_target: target
@@ -728,6 +761,7 @@ class KatakataIrb::TypeSimulator
   end
 
   def match_pattern(target, pattern, scope)
+    breakable = -> { scope.store_jump PATTERNMATCH_BREAK }
     types = target.types
     case pattern
     in [:var_field, [:@ident, name,]]
@@ -736,17 +770,20 @@ class KatakataIrb::TypeSimulator
     in [:@int | :@float | :@rational | :@imaginary | :@CHAR | :symbol_literal | :string_literal | :regexp_literal,]
     in [:begin, statement] # in (statement)
       simulate_evaluate statement, scope
+      breakable.call
     in [:binary, lpattern, :|, rpattern]
       match_pattern target, lpattern, scope
-      match_pattern target, rpattern, scope
+      scope.conditional { match_pattern target, rpattern, scope }
+      breakable.call
     in [:binary, lpattern, :'=>', [:var_field, [:@ident, name,]] => rpattern]
-      if lpattern in [:var_ref, [:@const, const_name,]]
+      if lpattern in [:var_ref, [:@const, _const_name,]]
         const_value = simulate_evaluate lpattern, scope
         if (const_value in KatakataIrb::Types::SingletonType) && const_value.module_or_class.is_a?(Class)
           scope[name] = KatakataIrb::Types::InstanceType.new const_value.module_or_class
         else
           scope[name] = KatakataIrb::Types::OBJECT
         end
+        breakable.call
       else
         match_pattern target, lpattern, scope
         match_pattern target, rpattern, scope
@@ -760,6 +797,7 @@ class KatakataIrb::TypeSimulator
       end
       if splat in [:var_field, [:@ident, name,]]
         scope[name] = KatakataIrb::Types::InstanceType.new Array, Elem: elem
+        breakable.call
       end
       post_items&.each do |item|
         match_pattern elem, item, scope
@@ -770,18 +808,21 @@ class KatakataIrb::TypeSimulator
       key_type = KatakataIrb::Types::UnionType[*hash_types.filter_map { _1.params[:K] }]
       value_type = KatakataIrb::Types::UnionType[*hash_types.filter_map { _1.params[:V] }]
       items&.each do |key_pattern, value_pattern|
-        if key_pattern in [:@label, label,]
+        if (key_pattern in [:@label, label,]) && !value_pattern
           name = label.delete ':'
-          scope[name] = value_type unless value_pattern
+          scope[name] = value_type
+          breakable.call
         end
         match_pattern value_type, value_pattern, scope if value_pattern
       end
       if splat in [:var_field, [:@ident, name,]]
         scope[name] = KatakataIrb::Types::InstanceType.new Hash, K: key_type, V: value_type
+        breakable.call
       end
     in [:if_mod, cond, ifpattern]
-      simulate_evaluate cond, scope
       match_pattern target, ifpattern, scope
+      simulate_evaluate cond, scope
+      breakable.call
     in [:dyna_symbol,]
     in [:const_path_ref,]
     else
@@ -852,6 +893,8 @@ class KatakataIrb::TypeSimulator
         scope[name] = value || KatakataIrb::Types::OBJECT
       in [:mlhs, *mlhs]
         evaluate_massign mlhs, value || [], scope
+      in nil
+        # a, *, b = value
       end
     end
   end
@@ -930,17 +973,20 @@ class KatakataIrb::TypeSimulator
       [args, [], nil]
     in [:args_add_block, [:args_add_star,] => args, block_arg]
       args, kwargs, = retrieve_method_args args
+      block_arg = [:void_stmt] if block_arg.nil? # method(*splat, &)
       [args, kwargs, block_arg]
     in [:args_add_block, [*args, [:bare_assoc_hash,] => kw], block_arg]
+      block_arg = [:void_stmt] if block_arg.nil? # method(**splat, &)
       _, kwargs = retrieve_method_args kw
       [args, kwargs, block_arg]
     in [:args_add_block, [*args], block_arg]
+      block_arg = [:void_stmt] if block_arg.nil? # method(arg, &)
       [args, [], block_arg]
     in [:bare_assoc_hash, kws]
       kwargs = []
       kws.each do |kw|
         if kw in [:assoc_splat, value,]
-          kwargs << KatakataIrb::Types::Splat.new(value)
+          kwargs << KatakataIrb::Types::Splat.new(value) if value
         elsif kw in [:assoc_new, [:@label, label,] => key, nil]
           name = label.delete ':'
           kwargs << [key, [:__var_ref_or_call, [name =~ /\A[A-Z]/ ? :@const : :@ident, name, [0, 0]]]]
@@ -955,7 +1001,7 @@ class KatakataIrb::TypeSimulator
       [args, kwargs, nil]
     in [:args_add_star, pre_args, star_arg, *post_args]
       pre_args, = retrieve_method_args pre_args if pre_args in [:args_add_star,]
-      args = [*pre_args, KatakataIrb::Types::Splat.new(star_arg), *post_args]
+      args = star_arg ? [*pre_args, KatakataIrb::Types::Splat.new(star_arg), *post_args] : pre_args + post_args
       [args, [], nil]
     in [:arg_paren, args]
       args ? retrieve_method_args(args) : [[], [], nil]
@@ -1025,7 +1071,7 @@ class KatakataIrb::TypeSimulator
 
   def evaluate_assign_params(params, values, scope)
     values = values.dup
-    params => [:params, pre_required, optional, rest, post_required, keywords, keyrest, block]
+    params => [:params, pre_required, optional, rest, post_required, _keywords, keyrest, block]
     size = (pre_required&.size || 0) + (optional&.size || 0) + (post_required&.size || 0) + (rest ? 1 : 0)
     if values.size == 1 && size >= 2
       value = values.first
@@ -1042,6 +1088,7 @@ class KatakataIrb::TypeSimulator
       scope[name] = KatakataIrb::Types::InstanceType.new Array, Elem: KatakataIrb::Types::UnionType[*rest_values]
     end
     evaluate_massign post_required, post_values, scope if post_required
+    # TODO: assign keywords
     if keyrest in [:kwrest_param, [:@ident, name,]]
       scope[name] = KatakataIrb::Types::InstanceType.new Hash, K: KatakataIrb::Types::SYMBOL, V: KatakataIrb::Types::OBJECT
     end
@@ -1064,14 +1111,10 @@ class KatakataIrb::TypeSimulator
       name = label.delete ':'
       scope[name] = value ? simulate_evaluate(value, scope) : KatakataIrb::Types::OBJECT
     end
-    case keyrest
-    in [:args_forward] | nil
-    in [:kwrest_param, [:@ident, name,]]
+    if keyrest in [:kwrest_param, [:@ident, name,]]
         scope[name] = KatakataIrb::Types::HASH
     end
-    case block
-    in :& | nil
-    in [:blockarg, [:@ident, name,]]
+    if block in [:blockarg, [:@ident, name,]]
       scope[name] = KatakataIrb::Types::PROC
     end
   end

data/lib/katakata_irb/types.rb

@@ -17,7 +17,7 @@ module KatakataIrb::Types
       type_name = RBS::TypeName(ancestor.name).absolute!
       definition = (singleton ? rbs_builder.build_singleton(type_name) : rbs_builder.build_instance(type_name)) rescue nil
       method = definition&.methods&.[](method_name)
-      return method if definition
+      return method if method
     end
     nil
   end

data/lib/katakata_irb/version.rb

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

data/lib/katakata_irb.rb

@@ -1,3 +1,4 @@
+require 'io/console'
 module KatakataIrb
   def self.repl
     require 'katakata_irb/completor'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katakata_irb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-09 00:00:00.000000000 Z
+date: 2022-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs