katakata_irb 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46f9fc2dd4b85529dff8a278f183954e48d7c7386944672d588e09315f6151ef
-  data.tar.gz: ae0dbe97feb4f1150f16bd061ea346ac2ff45a19eb1d38be4b6ffa25941418ce
+  metadata.gz: ad93f43d988f169816f4e842bdb70eda5a866574664f6afb5c015ae60b2f2d3b
+  data.tar.gz: 700e29af39db9a73fb71f0f2e76cf4d87bcf801e31fddaef3514416e6d3699e1
 SHA512:
-  metadata.gz: a0306fd41b676ba4b65d3e739704f258950f7406deb4022455c11b4a1b6d42e98d5dceeb5a51e464e1fba36b42705ae6a87b237a2cd24d206f132ca9baa26125
-  data.tar.gz: 6eddf48f22628cd2ce4bb44e56be931b137f68b4d3194e374600c8e420eb2c84765021c5678bb30cabc0e8ce5f4229d0993c6cfa8502e5aaead8274cf4fd156c
+  metadata.gz: d53414d13852cd4d88a92b841fcd20d85a19efd7cb2dd15faac245e0cd944f10e12e5176ca6b03aa82ca3bd66981c56a0a6ad228a73f9e149b1a4ee9077c4f39
+  data.tar.gz: 734aa26486a262b1feaf059290d7526fb061a71cd584c8ec4fa4fdbeb3f8a2b1d29b9e5dd64549e33d87e9987e736aeb1be0ae366033af9533914ca38981c4a8

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.13.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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'type_simulator'
-require 'rbs'
-require 'rbs/cli'
+require_relative 'type_analyzer'
 require 'irb'
 require 'prism'
 
@@ -77,8 +75,8 @@ 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.is_a? KatakataIrb::Types::SingletonType
@@ -96,18 +94,42 @@ 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)
+          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, scope]
-        # when prev_analyze_result is const, current analyze result might be call
-        call_or_const_doc.call type if type
-      in [:gvar, _name, _scope]
-        name
+        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
@@ -193,22 +215,25 @@ module KatakataIrb::Completor
     end.join + "nil;\n"
     code = lvars_code + code
     ast = Prism.parse(code).value
-    name = code[/(@@|@|\$)?\w*\z/]
+    name = code[/(@@|@|\$)?\w*[!?=]?\z/]
     *parents, target_node = find_target ast, code.bytesize - name.bytesize
     return unless target_node
 
-    calculate_scope = -> { KatakataIrb::TypeSimulator.calculate_target_type_scope(binding, parents, target_node).last }
-    calculate_type_scope = ->(node) { KatakataIrb::TypeSimulator.calculate_target_type_scope binding, [*parents, target_node], node }
+    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
@@ -263,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/scope.rb

@@ -38,6 +38,8 @@ module KatakataIrb
     end
 
     def get_const(nesting, path, _key = nil)
+      return unless nesting
+
       result = path.reduce nesting do |mod, name|
         return nil unless mod.is_a?(Module) && module_own_constant?(mod, name)
         mod.const_get name
@@ -45,18 +47,25 @@ module KatakataIrb
       KatakataIrb::Types.type_from_object result
     end
 
+    def get_cvar(nesting, path, name, _key = nil)
+      return KatakataIrb::Types::NIL unless nesting
+
+      result = path.reduce nesting do |mod, n|
+        return KatakataIrb::Types::NIL unless mod.is_a?(Module) && module_own_constant?(mod, n)
+        mod.const_get n
+      end
+      value = result.class_variable_get name if result.is_a?(Module) && name.size >= 3 && result.class_variable_defined?(name)
+      Types.type_from_object value
+    end
+
     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 }
         when :gvar
           BaseScope.type_of(fallback: fallback) { @binding.eval name if @global_variables.include? name }
         end
@@ -81,6 +90,7 @@ module KatakataIrb
 
     def self.type_by_name(name)
       if name.start_with? '@@'
+        # "@@cvar" or "@@cvar::[module_id]::[module_path]"
         :cvar
       elsif name.start_with? '@'
         :ivar
@@ -88,7 +98,8 @@ module KatakataIrb
         :gvar
       elsif name.start_with? '%'
         :internal
-      elsif name[0].downcase != name[0]
+      elsif name[0].downcase != name[0] || name[0].match?(/\d/)
+        # "ConstName" or "[module_id]::[const_path]"
         :const
       else
         :lvar
@@ -101,10 +112,9 @@ module KatakataIrb
 
     def self.from_binding(binding, locals) = new(BaseScope.new(binding, binding.eval('self'), locals))
 
-    def initialize(parent, table = {}, trace_cvar: true, trace_ivar: true, trace_lvar: true, self_type: nil, nesting: nil)
+    def initialize(parent, table = {}, trace_ivar: true, trace_lvar: true, self_type: nil, nesting: nil)
       @parent = parent
       @level = parent.level + 1
-      @trace_cvar = trace_cvar
       @trace_ivar = trace_ivar
       @trace_lvar = trace_lvar
       @module_nesting = nesting ? [nesting, *parent.module_nesting] : parent.module_nesting
@@ -145,15 +155,13 @@ module KatakataIrb
     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
+      type == :ivar ? @trace_ivar : type == :lvar ? @trace_lvar : true
     end
 
     def level_of(name, var_type)
       case var_type
       when :ivar
         return level unless @trace_ivar
-      when :cvar
-        return level unless @trace_cvar
       when :gvar
         return 0
       end
@@ -167,14 +175,27 @@ module KatakataIrb
       value || @parent.get_const(nesting, path, key)
     end
 
+    def get_cvar(nesting, path, name, key = nil)
+      key ||= [name, nesting.__id__, path].join('::')
+      _l, value = @table[key]
+      value || @parent.get_cvar(nesting, path, name, key)
+    end
+
     def [](name)
       type = BaseScope.type_by_name(name)
       if type == :const
+        return get_const(nil, nil, name) || KatakataIrb::Types::NIL if name.include?('::')
+
         module_nesting.each do |(nesting, path)|
           value = get_const nesting, [*path, name]
           return value if value
         end
-        KatakataIrb::Types::NIL
+        return KatakataIrb::Types::NIL
+      elsif type == :cvar
+        return get_cvar(nil, nil, nil, name) if name.include?('::')
+
+        nesting, path = module_nesting.first
+        return get_cvar(nesting, path, name)
       end
       level, value = @table[name]
       if level
@@ -191,11 +212,28 @@ module KatakataIrb
       @table[key] = [0, value]
     end
 
+    def set_cvar(nesting, path, name, value)
+      key = [name, nesting.__id__, path].join('::')
+      @table[key] = [0, value]
+    end
+
     def []=(name, value)
       type = BaseScope.type_by_name(name)
       if type == :const
-        parent_module, parent_path = module_nesting.first
-        set_const parent_module, [*parent_path, name], value
+        if name.include?('::')
+          @table[name] = [0, value]
+        else
+          parent_module, parent_path = module_nesting.first
+          set_const parent_module, [*parent_path, name], value
+        end
+        return
+      elsif type == :cvar
+        if name.include?('::')
+          @table[name] = [0, value]
+        else
+          parent_module, parent_path = module_nesting.first
+          set_cvar parent_module, parent_path, name, value
+        end
         return
       end
       variable_level = level_of name, type
@@ -285,8 +323,8 @@ module KatakataIrb
     end
 
     def table_class_variables
-      cvars = @table.keys.select { BaseScope.type_by_name(_1) == :cvar }
-      cvars |= @parent.table_class_variables if @parent.mutable? && @trace_cvar
+      cvars = @table.keys.filter_map { _1.split('::', 2).first if BaseScope.type_by_name(_1) == :cvar }
+      cvars |= @parent.table_class_variables if @parent.mutable?
       cvars
     end