katakata_irb 0.1.12 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de309515e451688552ff4758e266ba13966dfef8e62601d0496e3dfc1df256c1
-  data.tar.gz: 9923f034c376e28156f7d4a8552f893a2d70546372f7feea0f0f04e5072d782a
+  metadata.gz: 034055ed4a5fcf5bde6a1b86723c2963f82ace7c5b0411cd9a3e09fd734b10d2
+  data.tar.gz: 3e04438496f0241815cf7b674db57f7b644360520d9d829d75d5be61b63b78e5
 SHA512:
-  metadata.gz: 956de3a2a11d2ab1d877dbc832010fe501c18d1708dc9371e3d7dec9b0a158c66a6a05456660336e72b321662cae4ef764f2f0e065c4f7eab2f542262f59fe43
-  data.tar.gz: 2cc3a0e8829e6567fa34dd9a3218db03a8b51f5733392680b759810395aaab62ed2ca18c2fbc52f67c2608d6c0e6107c22e4546dcfc0c3aa8f055450ee8287f0
+  metadata.gz: 4b406ecd5c611cdc86220efa506c403dff220db4be5fb1bc1fab10eeb70931f0d7eaee8a45a702a6addb5de793e0c219562975d769fe31616305cd87fe4cfa4a
+  data.tar.gz: 147b09a36c68a66c917fff2157797d1124ec06e0333ee7cec26ef83b9d726c398bb83bbdce81f88c1706067ecc3f9bf99506d5706d3b22ccc3c8aa2ee6ce5cb1

data/Gemfile

@@ -8,3 +8,4 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "minitest", "~> 5.0"
+gem "simplecov"

data/katakata_irb.gemspec

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

data/lib/katakata_irb/completor.rb

@@ -1,65 +1,72 @@
-require_relative 'nesting_parser'
-require_relative 'type_simulator'
-require 'rbs'
-require 'rbs/cli'
+# frozen_string_literal: true
+
+require_relative 'type_analyzer'
 require 'irb'
+require 'prism'
 
 module KatakataIrb::Completor
-  using KatakataIrb::TypeSimulator::LexerElemMatcher
   HIDDEN_METHODS = %w[Namespace TypeName] # defined by rbs, should be hidden
   singleton_class.attr_accessor :prev_analyze_result
 
+  def self.candidates_from_result(result)
+    candidates = case result
+    in [:require | :require_relative => method, name]
+      if IRB.const_defined? :RegexpCompletor # IRB::VERSION >= 1.8.2
+        path_completor = IRB::RegexpCompletor.new
+      elsif IRB.const_defined? :InputCompletor # IRB::VERSION <= 1.8.1
+        path_completor = IRB::InputCompletor
+      end
+      if !path_completor
+        []
+      elsif method == :require
+        path_completor.retrieve_files_to_require_from_load_path
+      else
+        path_completor.retrieve_files_to_require_relative_from_current_dir
+      end
+    in [:call_or_const, type, name, self_call]
+      ((self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS) | type.constants
+    in [:const, type, name, scope]
+      if type
+        scope_constants = type.types.flat_map do |t|
+          scope.table_module_constants(t.module_or_class) if t.is_a?(KatakataIrb::Types::SingletonType)
+        end
+        (scope_constants.compact | type.constants.map(&:to_s)).sort
+      else
+        scope.constants.sort
+      end
+    in [:ivar, name, scope]
+      ivars = scope.instance_variables.sort
+      name == '@' ? ivars + scope.class_variables.sort : ivars
+    in [:cvar, name, scope]
+      scope.class_variables
+    in [:gvar, name, scope]
+      scope.global_variables
+    in [:symbol, name]
+      Symbol.all_symbols.map { _1.inspect[1..] }
+    in [:call, type, name, self_call]
+      (self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS
+    in [:lvar_or_method, name, scope]
+      scope.self_type.all_methods.map(&:to_s) | scope.local_variables
+    else
+      []
+    end
+    [name || '', candidates]
+  end
+
   def self.setup
     KatakataIrb::Types.preload_in_thread
-    completion_proc = ->(target, preposing = nil, postposing = nil) do
+    completion_proc = ->(preposing, target, _postposing, bind:) do
       verbose, $VERBOSE = $VERBOSE, nil
       code = "#{preposing}#{target}"
-      irb_context = IRB.conf[:MAIN_CONTEXT]
-      binding = irb_context.workspace.binding
-      result = analyze code, binding
+      result = analyze code, bind
       KatakataIrb::Completor.prev_analyze_result = result
-      candidates = case result
-      in [:require | :require_relative => method, name]
-        if IRB.const_defined? :RegexpCompletor # IRB::VERSION >= 1.8.2
-          path_completor = IRB::RegexpCompletor.new
-        elsif IRB.const_defined? :InputCompletor # IRB::VERSION <= 1.8.1
-          path_completor = IRB::InputCompletor
-        end
-        if !path_completor
-          []
-        elsif method == :require
-          path_completor.retrieve_files_to_require_from_load_path
-        else
-          path_completor.retrieve_files_to_require_relative_from_current_dir
-        end
-      in [:call_or_const, type, name, self_call]
-        ((self_call ? type.all_methods: type.methods).map(&:to_s) - HIDDEN_METHODS) | type.constants
-      in [:const, type, name]
-        type.constants
-      in [:ivar, name, *_scope]
-        # TODO: scope
-        ivars = binding.eval('self').instance_variables rescue []
-        cvars = (binding.eval('self').class_variables rescue nil) if name == '@'
-        ivars | (cvars || [])
-      in [:cvar, name, *_scope]
-        # TODO: scope
-        binding.eval('self').class_variables rescue []
-      in [:gvar, name]
-        global_variables
-      in [:symbol, name]
-        Symbol.all_symbols.map { _1.inspect[1..] }
-      in [:call, type, name, self_call]
-        (self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS
-      in [:lvar_or_method, name, scope]
-        scope.self_type.all_methods.map(&:to_s) | scope.local_variables
-      else
-        []
-      end
+      name, candidates = candidates_from_result(result).dup
+
       all_symbols_pattern = /\A[ -\/:-@\[-`\{-~]*\z/
       candidates.map(&:to_s).select { !_1.match?(all_symbols_pattern) && _1.start_with?(name) }.uniq.sort.map do
         target + _1[name.size..]
       end
-    rescue => e
+    rescue SyntaxError, StandardError => e
       KatakataIrb.last_completion_error = e
       KatakataIrb.log_puts
       KatakataIrb.log_puts "#{e.inspect} stored to KatakataIrb.last_completion_error"
@@ -68,13 +75,13 @@ module KatakataIrb::Completor
       $VERBOSE = verbose
     end
 
-    doc_namespace_proc = ->(input) do
-      name = input[/[a-zA-Z_0-9]+[!?=]?\z/]
+    doc_namespace_proc = -> input do
+      name = input[/[a-zA-Z_0-9]*[!?=]?\z/]
       method_doc = -> type do
         type = type.types.find { _1.all_methods.include? name.to_sym }
-        if type in KatakataIrb::Types::SingletonType
+        if type.is_a? KatakataIrb::Types::SingletonType
           "#{KatakataIrb::Types.class_name_of(type.module_or_class)}.#{name}"
-        elsif type in KatakataIrb::Types::InstanceType
+        elsif type.is_a? KatakataIrb::Types::InstanceType
           "#{KatakataIrb::Types.class_name_of(type.klass)}##{name}"
         end
       end
@@ -87,18 +94,44 @@ module KatakataIrb::Completor
         end
       end
 
+      value_doc = -> type do
+        return unless type
+        type.types.each do |t|
+          case t
+          when KatakataIrb::Types::SingletonType
+            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
+      end
+
       case KatakataIrb::Completor.prev_analyze_result
       in [:call_or_const, type, _name, _self_call]
         call_or_const_doc.call type
-      in [:const, type, _name]
-        # when prev_analyze_result is const, current analyze result might be call
-        call_or_const_doc.call type
-      in [:gvar, _name]
-        name
+      in [:const, type, _name, scope]
+        if type
+          call_or_const_doc.call type
+        else
+          value_doc.call scope[name]
+        end
+      in [:gvar, _name, scope]
+        value_doc.call scope["$#{name}"]
+      in [:ivar, _name, scope]
+        value_doc.call scope["@#{name}"]
+      in [:cvar, _name, scope]
+        value_doc.call scope["@@#{name}"]
       in [:call, type, _name, _self_call]
         method_doc.call type
       in [:lvar_or_method, _name, scope]
-        method_doc.call scope.self_type unless scope.local_variables.include?(name)
+        if scope.local_variables.include?(name)
+          value_doc.call scope[name]
+        else
+          method_doc.call scope.self_type
+        end
       else
       end
     end
@@ -106,15 +139,16 @@ module KatakataIrb::Completor
     if IRB.const_defined? :RegexpCompletor # IRB::VERSION >= 1.8.2
       IRB::RegexpCompletor.class_eval do
         define_method :completion_candidates do |preposing, target, postposing, bind:|
-          completion_proc.call(target, preposing, postposing)
+          completion_proc.call(preposing, target, postposing, bind: bind)
         end
         define_method :doc_namespace do |_preposing, matched, _postposing, bind:|
           doc_namespace_proc.call matched
         end
       end
     elsif IRB.const_defined? :InputCompletor # IRB::VERSION <= 1.8.1
-      IRB::InputCompletor::CompletionProc.define_singleton_method :call do |*args|
-        completion_proc.call(*args)
+      IRB::InputCompletor::CompletionProc.define_singleton_method :call do |target, preposing = '', postposing = ''|
+        bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+        completion_proc.call(preposing, target, postposing, bind: bind)
       end
       IRB::InputCompletor.singleton_class.prepend(
         Module.new do
@@ -174,179 +208,93 @@ module KatakataIrb::Completor
     Reline.add_dialog_proc(:show_type, type_dialog_proc, Reline::DEFAULT_DIALOG_CONTEXT)
   end
 
-  def self.empty_binding()
-    Kernel.binding
-  end
+  def self.analyze(code, binding = Object::TOPLEVEL_BINDING)
+    # Workaround for https://github.com/ruby/prism/issues/1592
+    return if code.match?(/%[qQ]\z/)
 
-  def self.analyze(code, binding = empty_binding)
     lvars_code = binding.local_variables.map do |name|
       "#{name}="
     end.join + "nil;\n"
     code = lvars_code + code
-    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/
-        # 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>.+))/
-        $/ + ($1 || $2 || $3) + $/
-      when ':"', ":'", ':'
-        t.tok[1]
-      when '?'
-        # ternary operator
-        ' : value'
-      when '|'
-        # block args
-        '|'
-      else
-        $/ + 'end'
-      end
-    end
-    # remove error tokens
-    tokens.pop while tokens&.last&.tok&.empty?
+    ast = Prism.parse(code).value
+    name = code[/(@@|@|\$)?\w*[!?=]?\z/]
+    *parents, target_node = find_target ast, code.bytesize - name.bytesize
+    return unless target_node
 
-    case tokens.last
-    in { event: :on_ignored_by_ripper, tok: '.' }
-      suffix = 'method'
-      name = ''
-    in { dot: true }
-      suffix = 'method'
-      name = ''
-    in { event: :on_symbeg }
-      suffix = 'symbol'
-      name = ''
-    in { event: :on_ident | :on_kw, tok: }
-      return unless code.delete_suffix! tok
-      suffix = 'method'
-      name = tok
-    in { event: :on_const, tok: }
-      return unless code.delete_suffix! tok
-      suffix = 'Const'
-      name = tok
-    in { event: :on_tstring_content, tok: }
-      return unless code.delete_suffix! tok
-      suffix = 'string'
-      name = tok.rstrip
-    in { event: :on_gvar, tok: }
-      return unless code.delete_suffix! tok
-      suffix = '$gvar'
-      name = tok
-    in { event: :on_ivar, tok: }
-      return unless code.delete_suffix! tok
-      suffix = '@ivar'
-      name = tok
-    in { event: :on_cvar, tok: }
-      return unless code.delete_suffix! tok
-      suffix = '@@cvar'
-      name = tok
-    else
-      return
-    end
-    sexp = Ripper.sexp code + suffix + closings.reverse.join
-    lines = code.lines
-    line_no = lines.size
-    col = lines.last.bytesize
-    if lines.last.end_with? "\n"
-      line_no += 1
-      col = 0
-    end
+    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 sexp in [:program, [_lvars_exp, *rest_statements]]
-      sexp = [:program, rest_statements]
+    if target_node.is_a?(Prism::StringNode) || target_node.is_a?(Prism::InterpolatedStringNode)
+      args_node = parents[-1]
+      call_node = parents[-2]
+      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
 
-    *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]]
-    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
-    end
-    return unless expression
-    calculate_scope = -> { KatakataIrb::TypeSimulator.calculate_binding_scope binding, parents, expression }
-    calculate_receiver = -> receiver { KatakataIrb::TypeSimulator.calculate_receiver binding, parents, receiver }
+    case target_node
+    when Prism::SymbolNode
+      if parents.last.is_a? Prism::BlockArgumentNode # method(&:target)
+        receiver_type, _scope = calculate_type_scope.call target_node
+        [:call, receiver_type, name, false]
+      else
+        [:symbol, name] unless name.empty?
+      end
+    when Prism::CallNode
+      return [:lvar_or_method, name, calculate_scope.call] if target_node.receiver.nil?
 
-    if (target in [:@tstring_content,]) && (parents[-4] in [:command, [:@ident, 'require' | 'require_relative' => require_method,],])
-      # `require 'target'`
-      return [require_method.to_sym, name.rstrip]
-    end
-    if (target in [:@ident,]) && (expression in [:symbol,]) && (parents[-2] in [:args_add_block, Array => _args, [:symbol_literal, ^expression]])
-      # `method(&:target)`
-      receiver_ref = [:var_ref, [:@ident, '_1', [0, 0]]]
-      block_statements = [receiver_ref]
-      parents[-1] = parents[-2][-1] = [:brace_block, nil, block_statements]
-      parents << block_statements
-      return [:call, calculate_receiver.call(receiver_ref), name, false]
-    end
-    case expression
-    in [:vcall | :var_ref, [:@ident,]]
+      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, receiver_type, name, self_call]
+    when Prism::LocalVariableReadNode, Prism::LocalVariableTargetNode
       [:lvar_or_method, name, calculate_scope.call]
-    in [:symbol, [:@ident | :@const | :@op | :@kw,]]
-      [:symbol, name] unless name.empty?
-    in [:var_ref | :const_ref, [:@const,]]
-      # TODO
-      [:const, KatakataIrb::Types::SingletonType.new(Object), name]
-    in [:var_ref, [:@gvar,]]
-      [:gvar, name]
-    in [:var_ref, [:@ivar,]]
-      [: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, [:@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',]])
-      [: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,] | [:field | :var_field | :const_path_field,] | [:defs,] | [:rest_param,] | [:kwrest_param,] | [:blockarg,] | [[:@ident,],]
-    in [Array,] # `xstring`, /regexp/
-    else
-      KatakataIrb.log_puts
-      KatakataIrb.log_puts [:UNIMPLEMENTED_EXPRESSION, expression].inspect
-      KatakataIrb.log_puts
-      nil
+    when Prism::ConstantReadNode, Prism::ConstantTargetNode
+      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, receiver, name, scope]
+        else # ::A
+          scope = calculate_scope.call
+          [:const, KatakataIrb::Types::SingletonType.new(Object), name, scope]
+        end
+      else
+        [:const, nil, name, calculate_scope.call]
+      end
+    when Prism::GlobalVariableReadNode, Prism::GlobalVariableTargetNode
+      [:gvar, name, calculate_scope.call]
+    when Prism::InstanceVariableReadNode, Prism::InstanceVariableTargetNode
+      [:ivar, name, calculate_scope.call]
+    when Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
+      [:cvar, name, calculate_scope.call]
     end
   end
 
-  def self.find_target(sexp, line, col, stack = [sexp])
-    return unless sexp.is_a? Array
-    sexp.each do |child|
-      case child
-      in [Symbol, String, [Integer => l, Integer => c]]
-        if l == line && c == col
-          stack << child
-          return stack
-        end
-      else
-        stack << child
-        result = find_target(child, line, col, stack)
-        return result if result
-        stack.pop
+  def self.find_target(node, position)
+    location = (
+      case node
+      when Prism::CallNode
+        node.message_loc
+      when Prism::SymbolNode
+        node.value_loc
+      when Prism::StringNode
+        node.content_loc
+      when Prism::InterpolatedStringNode
+        node.closing_loc if node.parts.empty?
       end
+    )
+    return [node] if location&.start_offset == position
+
+    node.child_nodes.each do |n|
+      next unless n.is_a? Prism::Node
+      match = find_target(n, position)
+      next unless match
+      match.unshift node
+      return match
     end
-    nil
+
+    [node] if node.location.start_offset == position
   end
 end