katakata_irb 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e03e0f334a22895540f29f3bb27551bff9bfcbede5aac767559006edbc77118f
-  data.tar.gz: 4db442409ca2ac1d853b4e7675ff3ac10aed0d6ced431d1abdbe2eea7a1fa298
+  metadata.gz: 297457c829dac09ddee68c1cc5365acfcc2583e0282fb1070ebae8fa138523ba
+  data.tar.gz: a45663afa386d4093814a3ea2a49c98cb03e90004e2a42c0dc723f4686500a51
 SHA512:
-  metadata.gz: fb7d8eae8b68d497c6e0c5c0d9bc8d8455d5af5638fb680b3048166188a1035a2e36229a7555203de4f8d18bc3089b92f441f496d6e2a074ad61587805b6de82
-  data.tar.gz: 75ef2f2f26505c98e3550342493474f47f11623fd1342f0529249e6e902e95f5ebf03f5053974c6813beee3697c0d13cb5a0adec073c65ece35dce9a3e3f01ed
+  metadata.gz: e66cd04bba34272f585adb1a6dde686a49d064604a48b1c0d14093474857b30537f6b05dd965eaf7ae822b174e373122479c05a643cc951fe4ecea3009a625c6
+  data.tar.gz: 4cb475b48b8e73db73340a1a11c97b087f99d2d6159e235d93a8845e4a718e9b18deb4e693d86059ba98bdbecbf41f24c13cb70d969fdd6d18f9cb171c76478b

data/katakata_irb.gemspec

@@ -30,6 +30,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 'rbs'
 
   # For more information and examples about making a new gem, check out our

data/lib/katakata_irb/completor.rb

@@ -10,6 +10,7 @@ module KatakataIrb::Completor
   singleton_class.attr_accessor :prev_analyze_result
 
   def self.setup
+    KatakataIrb::Types.preload_in_thread
     completion_proc = ->(target, preposing = nil, postposing = nil) do
       code = "#{preposing}#{target}"
       irb_context = IRB.conf[:MAIN_CONTEXT]
@@ -54,14 +55,14 @@ module KatakataIrb::Completor
     IRB::InputCompletor::CompletionProc.define_singleton_method :call do |*args|
       completion_proc.call(*args)
     rescue => e
-      $error = e
+      KatakataIrb.last_completion_error = e
       KatakataIrb.log_puts
-      KatakataIrb.log_puts "#{e.inspect} stored to $error"
+      KatakataIrb.log_puts "#{e.inspect} stored to KatakataIrb.last_completion_error"
       KatakataIrb.log_puts
     end
 
     IRB::InputCompletor.singleton_class.prepend Module.new{
-      def retrieve_completion_data(input, _bind: IRB.conf[:MAIN_CONTEXT].workspace.binding, doc_namespace: false)
+      def retrieve_completion_data(input, doc_namespace: false, **)
         return super unless doc_namespace
         name = input[/[a-zA-Z_0-9]+[!?=]?\z/]
         method_doc = -> type do
@@ -100,37 +101,45 @@ module KatakataIrb::Completor
     setup_type_dialog
   end
 
+  def self.type_dialog_content
+    receiver_type = (
+      case KatakataIrb::Completor.prev_analyze_result
+      in [:call_or_const, type, name, _self_call] if name.empty?
+        type
+      in [:call, type, name, _self_call] if name.empty?
+        type
+      else
+        return
+      end
+    )
+    if KatakataIrb::Types.rbs_builder.nil? && !KatakataIrb::Types.rbs_load_error
+      return [' Loading ', ' RBS... ']
+    end
+    types = receiver_type.types
+    contents = types.filter_map do |type|
+      case type
+      when KatakataIrb::Types::InstanceType
+        type.inspect_without_params
+      else
+        type.inspect
+      end
+    end.uniq
+    contents if contents.any?
+  end
+
   def self.setup_type_dialog
     type_dialog_proc = -> {
       return if just_cursor_moving && completion_journey_data
       cursor_pos_to_render, _result, pointer, autocomplete_dialog = context.last(4)
       return unless cursor_pos_to_render && autocomplete_dialog&.width && pointer.nil?
-      receiver_type = (
-        case KatakataIrb::Completor.prev_analyze_result
-        in [:call_or_const, type, name, _self_call] if name.empty?
-          type
-        in [:call, type, name, _self_call] if name.empty?
-          type
-        else
-          return
-        end
-      )
-      return unless receiver_type
-      types = type.types
-      contents = types.filter_map do |type|
-        case type
-        when KatakataIrb::Types::InstanceType
-          type.inspect_without_params
-        else
-          type.inspect
-        end
-      end.uniq
-      return if contents.empty?
+      contents = KatakataIrb::Completor.type_dialog_content
+      return unless contents&.any?
 
       width = contents.map { Reline::Unicode.calculate_width _1 }.max
       x = cursor_pos_to_render.x + autocomplete_dialog.width
       y = cursor_pos_to_render.y
-      Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: 44, fg_color: 37)
+      info = { pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: 44, fg_color: 37 }
+      Reline::DialogRenderInfo.new(**info.slice(*Reline::DialogRenderInfo.members))
     }
     Reline.add_dialog_proc(:show_type, type_dialog_proc, Reline::DEFAULT_DIALOG_CONTEXT)
   end
@@ -144,12 +153,11 @@ module KatakataIrb::Completor
       "#{name}="
     end.join + "nil;\n"
     code = lvars_code + code
-    tokens = RubyLex.ripper_lex_without_warning code
-    tokens = KatakataIrb::NestingParser.interpolate_ripper_ignored_tokens code, tokens
-    last_opens = KatakataIrb::NestingParser.parse(tokens)
+    tokens = KatakataIrb::NestingParser.tokenize code
+    last_opens = KatakataIrb::NestingParser.open_tokens(tokens)
     closings = last_opens.map do |t|
       case t.tok
-      when /\A%.[<>]\z/
+      when /\A%.?[<>]\z/
         $/ + '>'
       when '{', '#{', /\A%.?[{}]\z/
         $/ + '}'
@@ -233,7 +241,9 @@ module KatakataIrb::Completor
     in_class_module = parents&.any? { _1 in [:class | :module,] }
     icvar_available = !in_class_module
     return unless target in [_type, String, [Integer, Integer]]
-    if target in [:@ivar,]
+    if target in [:@gvar,]
+      return [:gvar, name]
+    elsif target in [:@ivar,]
       return [:ivar, name] if icvar_available
     elsif target in [:@cvar,]
       return [:cvar, name] if icvar_available
@@ -268,19 +278,26 @@ module KatakataIrb::Completor
       [:ivar, name, calculate_scope.call.self_type] if icvar_available
     in [:var_ref, [:@cvar,]]
       [:cvar, name, calculate_scope.call.self_type] if icvar_available
-    in [:call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, [:@ident | :@const,]]
+    in [:call, receiver, [:@op, '::',] | :'::', [:@ident | :@const,]]
+      self_call = (receiver in [:var_ref, [:@kw, 'self',]])
+      [:call_or_const, calculate_receiver.call(receiver), name, self_call]
+    in [:call, receiver, [:@period,], [:@ident | :@const,]]
+      self_call = (receiver in [:var_ref, [:@kw, 'self',]])
+      [:call, calculate_receiver.call(receiver), name, self_call]
+    in [:call, receiver, [:@op, '&.',], [:@ident | :@const,]]
       self_call = (receiver in [:var_ref, [:@kw, 'self',]])
-      [dot == :'::' ? :call_or_const : :call, calculate_receiver.call(receiver), name, self_call]
+      [:call, calculate_receiver.call(receiver).nonnillable, name, self_call]
     in [:const_path_ref, receiver, [:@const,]]
       [:const, calculate_receiver.call(receiver), name]
     in [:top_const_ref, [:@const,]]
       [:const, KatakataIrb::Types::SingletonType.new(Object), name]
-    in [:def,] | [:string_content,] | [:var_field,] | [:defs,] | [:rest_param,] | [:kwrest_param,] | [:blockarg,] | [[:@ident,],]
+    in [:def,] | [:string_content,] | [:field | :var_field | :const_path_field,] | [:defs,] | [:rest_param,] | [:kwrest_param,] | [:blockarg,] | [[:@ident,],]
     in [Array,] # `xstring`, /regexp/
     else
       KatakataIrb.log_puts
-      KatakataIrb.log_puts [:NEW_EXPRESSION, expression].inspect
+      KatakataIrb.log_puts [:UNIMPLEMENTED_EXPRESSION, expression].inspect
       KatakataIrb.log_puts
+      nil
     end
   end
 

data/lib/katakata_irb/nesting_parser.rb

@@ -1,4 +1,18 @@
 module KatakataIrb::NestingParser
+  ERROR_TOKENS = %i[
+    on_parse_error
+    compile_error
+    on_assign_error
+    on_alias_error
+    on_class_name_error
+    on_param_error
+  ]
+
+  def self.tokenize(code)
+    tokens = Ripper::Lexer.new(code).scan.reject { ERROR_TOKENS.include? _1.event }
+    KatakataIrb::NestingParser.interpolate_ripper_ignored_tokens code, tokens
+  end
+
   def self.interpolate_ripper_ignored_tokens(code, tokens)
     line_positions = code.lines.reduce([0]) { _1 << _1.last + _2.bytesize }
     prev_byte_pos = 0
@@ -26,9 +40,10 @@ module KatakataIrb::NestingParser
     interpolated
   end
 
-  IGNOREABLE_TOKENS = %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end]
+  IGNORE_TOKENS = %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end]
 
-  def self.parse(tokens)
+  # Scan each token and call the given block with array of token and other information for parsing
+  def self.scan_opens(tokens)
     opens = []
     pending_heredocs = []
     first_token_on_line = true
@@ -37,14 +52,14 @@ module KatakataIrb::NestingParser
       last_tok, state, args = opens.last
       case state
       when :in_unquoted_symbol
-        unless t.event == :on_sp
+        unless IGNORE_TOKENS.include?(t.event)
           opens.pop
           skip = true
         end
       when :in_lambda_head
         opens.pop if t.event == :on_tlambeg || (t.event == :on_kw && t.tok == 'do')
       when :in_method_head
-        unless IGNOREABLE_TOKENS.include?(t.event)
+        unless IGNORE_TOKENS.include?(t.event)
           next_args = []
           body = nil
           if args.include?(:receiver)
@@ -133,7 +148,7 @@ module KatakataIrb::NestingParser
         if t.event == :on_op && t.tok == '|'
           opens[-1] = [last_tok, nil]
           opens << [t, :in_block_args]
-        elsif !IGNOREABLE_TOKENS.include?(t.event)
+        elsif !IGNORE_TOKENS.include?(t.event)
           opens[-1] = [last_tok, nil]
         end
       when :in_block_args
@@ -201,6 +216,12 @@ module KatakataIrb::NestingParser
           opens << [t, nil]
         when :on_tstring_end, :on_regexp_end, :on_label_end
           opens.pop
+        when :on_symbeg
+          if t.tok == ':'
+            opens << [t, :in_unquoted_symbol]
+          else
+            opens << [t, nil]
+          end
         when :on_op
           case t.tok
           when '?'
@@ -210,12 +231,6 @@ module KatakataIrb::NestingParser
             # closing of `cond ? value : value``
             opens.pop
           end
-        when :on_symbeg
-          if t.tok == ':'
-            opens << [t, :in_unquoted_symbol]
-          else
-            opens << [t, nil]
-          end
         end
       end
       if t.event == :on_nl || t.event == :on_semicolon
@@ -232,29 +247,8 @@ module KatakataIrb::NestingParser
     opens.map(&:first) + pending_heredocs.reverse
   end
 
-  def self.parse_line(tokens)
-    line_tokens = []
-    prev_opens = []
-    min_depth = 0
-    output = []
-    last_opens = parse(tokens) do |t, 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.map(&:first)
-          output << [line_tokens, prev_opens, next_opens, min_depth]
-          prev_opens = next_opens
-          min_depth = prev_opens.size
-          line_tokens = []
-        end
-      else
-        line_tokens << [t, t.tok]
-      end
-    end
-    output << [line_tokens, prev_opens, last_opens, min_depth] if line_tokens.any?
-    output
+  def self.open_tokens(tokens)
+    # scan_opens without block will return a list of open tokens at last token position
+    scan_opens(tokens)
   end
 end

data/lib/katakata_irb/type_simulator.rb

@@ -80,6 +80,7 @@ class KatakataIrb::TypeSimulator
       end
       if @dig_targets.dig? sexp
         params in [:paren, params]
+        params ||= [:params, nil, nil, nil, nil, nil, nil, nil] # params might be nil in ruby 3.0
         params_table = extract_param_names(params).to_h { [_1, KatakataIrb::Types::NIL] }
         method_scope = KatakataIrb::Scope.new(
           scope,
@@ -556,7 +557,7 @@ class KatakataIrb::TypeSimulator
       scope.update pattern_scope
       KatakataIrb::Types::UnionType[*results]
     in [:case, target_exp, match_exp]
-      target = simulate_evaluate target_exp, scope
+      target = target_exp ? simulate_evaluate(target_exp, scope) : KatakataIrb::Types::NIL
       simulate_evaluate match_exp, scope, case_target: target
     in [:void_stmt]
       KatakataIrb::Types::NIL
@@ -768,9 +769,9 @@ class KatakataIrb::TypeSimulator
     case sexp
     in [:fcall | :vcall, [:@ident | :@const | :@kw | :@op, method,]] # hoge
       [nil, method, [], [], nil, false]
-    in [:call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, :call]
+    in [:call, receiver, [:@period,] | [:@op, '&.',] | [:@op, '::',] | :'::' => dot, :call]
       [receiver, :call, [], [], nil, optional[dot]]
-    in [:call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, method]
+    in [:call, receiver, [:@period,] | [:@op, '&.',] | [:@op, '::',] | :'::' => dot, method]
       method => [:@ident | :@const | :@kw | :@op, method,] unless method == :call
       [receiver, method, [], [], nil, optional[dot]]
     in [:command, [:@ident | :@const | :@kw | :@op, method,], args] # hoge 1, 2
@@ -894,6 +895,7 @@ class KatakataIrb::TypeSimulator
       in [:field | :aref_field,]
         # a.b, c[i] = value
       in [:excessed_comma]
+      in [:args_forward]
       end
     end
     [*pre_required, *post_required].each(&extract_mlhs)

data/lib/katakata_irb/types.rb

@@ -3,8 +3,12 @@ require 'rbs/cli'
 
 module KatakataIrb; end
 module KatakataIrb::Types
-  def self.rbs_builder
-    @rbs_builder ||= load_rbs_builder
+  singleton_class.attr_reader :rbs_builder, :rbs_load_error
+
+  def self.preload_in_thread
+    @loader_thread ||= Thread.new do
+      @rbs_builder = load_rbs_builder
+    end
   end
 
   def self.load_rbs_builder
@@ -12,8 +16,10 @@ module KatakataIrb::Types
     loader.add path: Pathname('sig')
     RBS::DefinitionBuilder.new env: RBS::Environment.from_loader(loader).resolve_type_names
   rescue => e
-    puts "\r\nKatakataIRB failed to initialize RBS::DefinitionBuilder\r\n#{e}\r\n"
-    Object.new
+    @rbs_load_error = e
+    puts "\r\nKatakataIRB failed to initialize RBS::DefinitionBuilder: #{e.class}\r\n"
+    puts "See `KatakataIrb::Types.rbs_load_error` for more details.\r\n"
+    nil
   end
 
   Splat = Struct.new :item
@@ -59,6 +65,8 @@ module KatakataIrb::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 ProcType
@@ -186,12 +194,19 @@ module KatakataIrb::Types
       @params = params
     end
     def transform() = yield(self)
-    def methods() = @klass.instance_methods
-    def all_methods() = @klass.instance_methods | @klass.private_instance_methods
+    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 = KatakataIrb::Types.class_name_of(@klass)
+      return {} unless name
+
+      type_name = RBS::TypeName(name).absolute!
+      KatakataIrb::Types.rbs_builder.build_instance(type_name).methods rescue {}
+    end
     def inspect
       if params.empty?
         inspect_without_params
@@ -390,8 +405,8 @@ module KatakataIrb::Types
 
   def self.match_free_variables(vars, types, values)
     accumulator = {}
-    types.zip(values).each do |t, v|
-      _match_free_variable(vars, t, v, accumulator)
+    types.zip values do |t, v|
+      _match_free_variable(vars, t, v, accumulator) if v
     end
     accumulator.transform_values { UnionType[*_1] }
   end

data/lib/katakata_irb/version.rb

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

data/lib/katakata_irb.rb

@@ -1,13 +1,17 @@
 require 'katakata_irb/version'
 require 'katakata_irb/completor'
+require 'katakata_irb/types'
 
 module KatakataIrb
-  def self.log_output=(output)
-    @log_output = output
-  end
-
-  def self.log_puts(...)
-    STDOUT.cooked { @log_output&.puts(...) }
+  class << self
+    attr_accessor :log_output, :last_completion_error
+    def log_puts(...)
+      if STDOUT.tty?
+        STDOUT.cooked { log_output&.puts(...) }
+      else
+        log_output&.puts(...)
+      end
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katakata_irb
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-09 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: reline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement
@@ -46,7 +60,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -82,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: IRB with Typed Completion

data/Gemfile.lock

@@ -1,29 +0,0 @@
-PATH
-  remote: .
-  specs:
-    katakata_irb (0.1.8)
-      irb (>= 1.4.0)
-      rbs
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    io-console (0.6.0)
-    irb (1.6.4)
-      reline (>= 0.3.0)
-    minitest (5.18.0)
-    rake (13.0.6)
-    rbs (3.1.0)
-    reline (0.3.3)
-      io-console (~> 0.5)
-
-PLATFORMS
-  x86_64-darwin-20
-
-DEPENDENCIES
-  katakata_irb!
-  minitest (~> 5.0)
-  rake (~> 13.0)
-
-BUNDLED WITH
-   2.4.5