katakata_irb 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e13d1b43d98e8be7595125b4e1e27533d83da1ee4d87df0dfb613d8fb8adee4
-  data.tar.gz: ae508bc65cd1049100fe4811b1d2b27036b30131cab13821d52b637e91e2ed41
+  metadata.gz: df817c7e7806e6ea21aa82e14a694130b0db5dd68c74ea84790b90ad3b895fb7
+  data.tar.gz: 9faa1d72b27f35bccc5b4d2dcc5c9f50b4dd9946ba5d63374d3083e933e62c38
 SHA512:
-  metadata.gz: be9ed49c8de27772f7ec154df136134e9d5319a851fe392656a67d3c49069ed040a41b2af8deb6e81577c0c59c6d5bc0918a8165e09ccab2bce15fd6f09abba8
-  data.tar.gz: 8d9554e6532488742e156d39e7ee63c3c2461900db42badfd0d49990e35769b1e0f34a8cd746d5aab57839d3f31e894a081ec42389cd2383dafab5043d3fa578
+  metadata.gz: 9bec77d0fd1f9484278541e48a964c683ef2546b8a5b107e731d7979b634c4c8fb9ce2b68261603fc5f4ad8eb83cfb3018e11881a2ecd4096d268e7be0e97405
+  data.tar.gz: b6520a88ad8644423f24e7c02e783bf1cb388b3a00d2c16151b97e08598f1fd80f55f8346562d00c9d2ec0e2b619d4f4db23eeba5834c39b9ebfc72ce765cbdb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    katakata_irb (0.1.4)
+    katakata_irb (0.1.6)
       irb (>= 1.4.0)
       rbs
 

data/lib/katakata_irb/completor.rb

@@ -27,18 +27,18 @@ module KatakataIrb::Completor
         ((self_call ? type.all_methods: type.methods).map(&:to_s) - HIDDEN_METHODS) | type.constants
       in [:const, type, name]
         type.constants
-      in [:ivar, name, _scope]
+      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]
+      in [:cvar, name, *_scope]
         # TODO: scope
         binding.eval('self').class_variables rescue []
       in [:gvar, name]
         global_variables
       in [:symbol, name]
-        Symbol.all_symbols
+        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]
@@ -67,15 +67,15 @@ module KatakataIrb::Completor
         method_doc = -> type do
           type = type.types.find { _1.all_methods.include? name.to_sym }
           if type in KatakataIrb::Types::SingletonType
-            "#{type.module_or_class.name}.#{name}"
+            "#{KatakataIrb::Types.class_name_of(type.module_or_class)}.#{name}"
           elsif type in KatakataIrb::Types::InstanceType
-            "#{type.klass.name}##{name}"
+            "#{KatakataIrb::Types.class_name_of(type.klass)}##{name}"
           end
         end
         call_or_const_doc = -> type do
           if name =~ /\A[A-Z]/
             type = type.types.grep(KatakataIrb::Types::SingletonType).find { _1.module_or_class.const_defined?(name) }
-            type.module_or_class == Object ? name : "#{type.module_or_class.name}::#{name}" if type
+            type.module_or_class == Object ? name : "#{KatakataIrb::Types.class_name_of(type.module_or_class)}::#{name}" if type
           else
             method_doc.call(type)
           end
@@ -97,9 +97,50 @@ module KatakataIrb::Completor
         end
       end
     }
+    setup_type_dialog
   end
 
-  def self.analyze(code, binding = Kernel.binding)
+  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
+          KatakataIrb::Types.class_name_of type.klass
+        when KatakataIrb::Types::SingletonType
+          module_name = KatakataIrb::Types.class_name_of type.module_or_class
+          "#{module_name}.itself" if module_name
+        end
+      end.uniq
+      return if contents.empty?
+
+      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)
+    }
+    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 = empty_binding)
     lvars_code = binding.local_variables.map do |name|
       "#{name}="
     end.join + "nil;\n"
@@ -124,10 +165,20 @@ module KatakataIrb::Completor
         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?
 
     case tokens.last
     in { event: :on_ignored_by_ripper, tok: '.' }
@@ -136,6 +187,9 @@ module KatakataIrb::Completor
     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'
@@ -148,10 +202,21 @@ module KatakataIrb::Completor
       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
@@ -175,16 +240,26 @@ module KatakataIrb::Completor
       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 }
+
     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
-    calculate_scope = -> { KatakataIrb::TypeSimulator.calculate_binding_scope binding, parents, expression }
-    calculate_receiver = -> receiver { KatakataIrb::TypeSimulator.calculate_receiver binding, parents, receiver }
+    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,]]
       [:lvar_or_method, name, calculate_scope.call]
     in [:symbol, [:@ident | :@const | :@op | :@kw,]]
-      [:symbol, name]
+      [:symbol, name] unless name.empty?
     in [:var_ref | :const_ref, [:@const,]]
       # TODO
       [:const, KatakataIrb::Types::SingletonType.new(Object), name]

data/lib/katakata_irb/nesting_parser.rb

@@ -26,6 +26,8 @@ module KatakataIrb::NestingParser
     interpolated
   end
 
+  IGNOREABLE_TOKENS = %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end]
+
   def self.parse(tokens)
     opens = []
     pending_heredocs = []
@@ -42,7 +44,7 @@ module KatakataIrb::NestingParser
       when :in_lambda_head
         opens.pop if t.event == :on_tlambeg || (t.event == :on_kw && t.tok == 'do')
       when :in_method_head
-        unless %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end].include?(t.event)
+        unless IGNOREABLE_TOKENS.include?(t.event)
           next_args = []
           body = nil
           if args.include?(:receiver)
@@ -127,13 +129,27 @@ module KatakataIrb::NestingParser
           skip = true if t.event == :on_kw && t.tok == 'do'
           opens[-1] = [last_tok, nil]
         end
+      when :in_block_head
+        if t.event == :on_op && t.tok == '|'
+          opens[-1] = [last_tok, nil]
+          opens << [t, :in_block_args]
+        elsif !IGNOREABLE_TOKENS.include?(t.event)
+          opens[-1] = [last_tok, nil]
+        end
+      when :in_block_args
+        if t.event == :on_op && t.tok == '|' && t.state.allbits?(Ripper::EXPR_BEG)
+          opens.pop
+          skip = true
+        end
       end
 
       unless skip
         case t.event
         when :on_kw
           case t.tok
-          when 'begin', 'class', 'module', 'do', 'case'
+          when 'do'
+            opens << [t, :in_block_head]
+          when 'begin', 'class', 'module', 'case'
             opens << [t, nil]
           when 'end'
             opens.pop
@@ -163,9 +179,15 @@ module KatakataIrb::NestingParser
               opens << [t, nil]
             end
           end
+        when :on_lbrace
+          if t.state.allbits?(Ripper::EXPR_LABEL)
+            opens << [t, nil]
+          else
+            opens << [t, :in_block_head]
+          end
         when :on_tlambda
           opens << [t, :in_lambda_head]
-        when :on_lparen, :on_lbracket, :on_lbrace, :on_tlambeg, :on_embexpr_beg, :on_embdoc_beg
+        when :on_lparen, :on_lbracket, :on_tlambeg, :on_embexpr_beg, :on_embdoc_beg
           opens << [t, nil]
         when :on_rparen, :on_rbracket, :on_rbrace, :on_embexpr_end, :on_embdoc_end
           opens.pop
@@ -179,6 +201,15 @@ module KatakataIrb::NestingParser
           opens << [t, nil]
         when :on_tstring_end, :on_regexp_end, :on_label_end
           opens.pop
+        when :on_op
+          case t.tok
+          when '?'
+            # opening of `cond ? value : value``
+            opens << [t, nil]
+          when ':'
+            # closing of `cond ? value : value``
+            opens.pop
+          end
         when :on_symbeg
           if t.tok == ':'
             opens << [t, :in_unquoted_symbol]

data/lib/katakata_irb/scope.rb

@@ -0,0 +1,256 @@
+require 'set'
+require_relative 'types'
+
+module KatakataIrb
+  class BaseScope
+    SELF = '%self'
+    BREAK_RESULT = '%break'
+    NEXT_RESULT = '%next'
+    RETURN_RESULT = '%return'
+    PATTERNMATCH_BREAK = '%match'
+    RAISE_BREAK = '%raise'
+
+    def initialize(binding, self_object)
+      @binding, @self_object = binding, self_object
+      @cache = { SELF => KatakataIrb::Types.type_from_object(self_object) }
+      @local_variables = binding.local_variables.map(&:to_s).to_set
+    end
+
+    def level() = 0
+
+    def level_of(name)
+      has?(name) ? 0 : nil
+    end
+
+    def mutable?() = false
+
+    def [](name)
+      @cache[name] ||= (
+        fallback = KatakataIrb::Types::NIL
+        case BaseScope.type_by_name name
+        when :cvar
+          BaseScope.type_of(fallback: fallback) { @self_object.class_variable_get name }
+        when :ivar
+          BaseScope.type_of(fallback: fallback) { @self_object.instance_variable_get name }
+        when :lvar
+          BaseScope.type_of(fallback: fallback) { @binding.local_variable_get(name) }
+        when :const
+          BaseScope.type_of(fallback: fallback) { @binding.eval name }
+        end
+      )
+    end
+
+    def self_type
+      self[SELF]
+    end
+
+    def local_variables
+      @local_variables.to_a
+    end
+
+    def self.type_of(fallback: KatakataIrb::Types::OBJECT)
+      begin
+        KatakataIrb::Types.type_from_object yield
+      rescue
+        fallback
+      end
+    end
+
+    def self.type_by_name(name)
+      if name.start_with? '@@'
+        :cvar
+      elsif name.start_with? '@'
+        :ivar
+      elsif name.start_with? '$'
+        :gvar
+      elsif name.start_with? '%'
+        :internal
+      elsif name[0].downcase != name[0]
+        :const
+      else
+        :lvar
+      end
+    end
+
+    def has?(name)
+      case BaseScope.type_by_name name
+      when :lvar
+        @local_variables.include? name
+      when :const
+        @binding.eval("#{name};true") rescue false
+      when :gvar, :cvar, :ivar
+        true
+      when :internal
+        true
+      end
+    end
+  end
+
+  class Scope < BaseScope
+    attr_reader :parent, :jump_branches, :mergeable_changes, :level, :lvars
+
+    def self.from_binding(binding) = new(BaseScope.new(binding, binding.eval('self')))
+
+    def initialize(parent, table = {}, trace_cvar: true, trace_ivar: true, trace_lvar: true, passthrough: false)
+      @table = table
+      @parent = parent
+      @level = parent.level + (passthrough ? 0 : 1)
+      @trace_cvar = trace_cvar
+      @trace_ivar = trace_ivar
+      @trace_lvar = trace_lvar
+      @passthrough = passthrough
+      @terminated = false
+      @jump_branches = []
+      @lvars = Set.new
+      @mergeable_changes = @changes = table.transform_values { [level, _1] }
+    end
+
+    def mutable? = true
+
+    def terminated?
+      @terminated
+    end
+
+    def terminate_with(type, value)
+      return if terminated?
+      store_jump type, value, @mergeable_changes
+      terminate
+    end
+
+    def store_jump(type, value, changes)
+      return if terminated?
+      if has_own?(type)
+        changes[type] = [level, value]
+        @jump_branches << changes
+      elsif @parent.mutable?
+        @parent.store_jump(type, value, changes)
+      end
+    end
+
+    def terminate
+      return if terminated?
+      @terminated = true
+      @changes = @mergeable_changes.dup
+    end
+
+    def branch_table_clone() = @tables.last.dup
+
+    def trace?(name)
+      return false unless @parent
+      type = BaseScope.type_by_name(name)
+      type == :cvar ? @trace_cvar : type == :ivar ? @trace_ivar : type == :lvar ? @trace_lvar : true
+    end
+
+    def level_of(name)
+      variable_level, = @changes[name]
+      variable_level || parent.level_of(name)
+    end
+
+    def [](name)
+      level, value = @changes[name]
+      if level
+        value
+      elsif trace? name
+        @parent[name] if trace? name
+      end
+    end
+
+    def []=(name, value)
+      variable_level = level_of(name) || level
+      @lvars << name if level == variable_level && BaseScope.type_by_name(name) == :lvar
+      @changes[name] = [variable_level, value]
+    end
+
+    def self_type
+      self[SELF]
+    end
+
+    def local_variables
+      lvar_keys = @changes.keys.select do |name|
+        BaseScope.type_by_name(name) == :lvar
+      end
+      lvar_keys |= @parent.local_variables if @trace_lvar
+      lvar_keys
+    end
+
+    def merge_jumps
+      if terminated?
+        @terminated = false
+        @changes = @mergeable_changes
+        merge @jump_branches
+        @terminated = true
+      else
+        merge [*@jump_branches, {}]
+      end
+    end
+
+    def conditional(&block)
+      run_branches(block, ->(_s) {}).first || KatakataIrb::Types::NIL
+    end
+
+    def never(&block)
+      block.call Scope.new(self, { BREAK_RESULT => nil, NEXT_RESULT => nil, PATTERNMATCH_BREAK => nil, RETURN_RESULT => nil, RAISE_BREAK => nil }, passthrough: true)
+    end
+
+    def run(*args, **option)
+      scope = Scope.new(self, *args, **option)
+      yield scope
+      merge_jumps
+      update scope
+    end
+
+    def touch_lvars(lvars)
+      lvars.each { self[_1] = self[_1] || KatakataIrb::Types::NIL }
+    end
+
+    def run_branches(*blocks)
+      results = []
+      branches = []
+      blocks.each do |block|
+        scope = Scope.new self, passthrough: true
+        result = block.call scope
+        touch_lvars scope.lvars if scope.level == level
+        next if scope.terminated?
+        results << result
+        branches << scope.mergeable_changes
+      end
+      terminate if branches.empty?
+      merge branches
+      results
+    end
+
+    def has?(name)
+      has_own?(name) || (trace?(name) && @parent.has?(name))
+    end
+
+    def has_own?(name)
+      @changes.key? name
+    end
+
+    def update(child_scope)
+      current_level = level
+      touch_lvars child_scope.lvars if child_scope.level == current_level
+      child_scope.mergeable_changes.each do |name, (level, value)|
+        self[name] = value if level <= current_level
+      end
+    end
+
+    protected
+
+    def merge(branches)
+      current_level = level
+      merge = {}
+      branches.each do |changes|
+        changes.each do |name, (level, value)|
+          next if current_level < level
+          (merge[name] ||= []) << value
+        end
+      end
+      merge.each do |name, values|
+        values << self[name] unless values.size == branches.size
+        values.compact!
+        self[name] = KatakataIrb::Types::UnionType[*values.compact] unless values.empty?
+      end
+    end
+  end
+end