hind 0.1.17 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba0a23c04400d06ebf294a87558c5893fb195b0e477acf49772598827f1afdba
-  data.tar.gz: a213c39aa228dd18612d45b85a1087aaec375ba3ba2477dc5dd7ff14dd0a094a
+  metadata.gz: df06e6747a2824041eec9a746d2ba16d6bbabf3cb927da9800157dbaeb2095a9
+  data.tar.gz: 93e7b0e378c3d242af3658a0d7b83687d2e454628e57f91d5c09a9927169b024
 SHA512:
-  metadata.gz: d806daccb7faa4378c8bd644ff094b6fb8dda612ecaae3536cdf5f2e6e6551ebbdd0d5de35612daa4a7e9727c2e51fee44c6a0fe029882397f19dbbda9a15cae
-  data.tar.gz: a0586d0ec3f980ae369138fd712fe670162be4ac6444f495fb8c414253fcfd251df4c4ccec80988305178ff20ddbb93034bbe1b812058b752b8a9fe14e31d66e
+  metadata.gz: 378c72668b6c0a39ef27fbaafd5053ea51fccdc80fed0d0ca721ace54d0eb1fb980030827503b84d3cc082649c4f627f1ca1f6e3e93bc9ebe44886efa2f0f6ac
+  data.tar.gz: 7fe5b6f0614d81bf0ae2181c63e9b11a06be8f02da670dc48e58e900e368c6c63557a8c456afa6e0f2bbc441e5688d50358298e856dfc156b685490b71c4a340

data/lib/hind/lsif/generator.rb

@@ -223,6 +223,44 @@ module Hind
         result_set_id
       end
 
+      def register_method_declaration(declaration)
+        return unless @current_uri && declaration[:node]
+
+        qualified_name = declaration[:name]
+
+        setup_document if @document_id.nil?
+        current_doc_id = @document_id
+
+        loc = declaration[:node].respond_to?(:name_loc) ? declaration[:node].name_loc : declaration[:node].location
+        range_id = create_range(loc)
+        return unless range_id
+
+        result_set_id = emit_vertex('resultSet')
+        emit_edge('next', range_id, result_set_id)
+
+        def_result_id = emit_vertex('definitionResult')
+        emit_edge('textDocument/definition', result_set_id, def_result_id)
+
+        emit_edge('item', def_result_id, [range_id], 'definitions', current_doc_id)
+
+        hover_id = emit_vertex('hoverResult', {
+          contents: [{
+            language: 'ruby',
+            value: "def #{declaration[:name].split('#').last}"
+          }]
+        })
+        emit_edge('textDocument/hover', result_set_id, hover_id)
+
+        declaration[:range_id] = range_id
+        declaration[:result_set_id] = result_set_id
+        declaration[:document_id] = current_doc_id
+        declaration[:file] = @current_uri
+
+        GlobalState.instance.add_method(qualified_name, declaration)
+
+        result_set_id
+      end
+
       def register_reference(reference)
         return unless @current_uri && reference[:node]
         return unless GlobalState.instance.has_declaration?(reference[:name])

data/lib/hind/lsif/global_state.rb

@@ -18,10 +18,12 @@ module Hind
         @classes = {}     # {qualified_name => {definitions: [{node:, scope:, file:, range_id:, result_set_id:, superclass:}]}}
         @modules = {}     # {qualified_name => {definitions: [{node:, scope:, file:, range_id:, result_set_id:}]}}
         @constants = {}   # {qualified_name => {node:, scope:, file:, range_id:, result_set_id:, value:}}
+        @methods = {}     # {qualified_name => {node:, scope:, file:, range_id:, result_set_id:}}
         @references = {}  # {qualified_name => [{file:, range_id:, document_id:}, ...]}
         @ranges = {}      # {file_path => [range_ids]}
         @range_cache = {} # {file_path => {[start_line, start_col, end_line, end_col] => range_id}}
         @result_sets = {} # {qualified_name => result_set_id}
+        @ancestors = {}   # {qualified_name => [{name:, type:}]}
         @project_id = nil
       end
 
@@ -58,6 +60,16 @@ module Hind
         @result_sets[qualified_name] = data[:result_set_id] if data[:result_set_id]
       end
 
+      def add_method(qualified_name, data)
+        @methods[qualified_name] = data
+        @result_sets[qualified_name] = data[:result_set_id] if data[:result_set_id]
+      end
+
+      def add_ancestor(qualified_name, mixed_in_module, type)
+        @ancestors[qualified_name] ||= []
+        @ancestors[qualified_name] << { name: mixed_in_module, type: type }
+      end
+
       def add_reference(qualified_name, file_path, range_id, document_id)
         @references[qualified_name] ||= []
         @references[qualified_name] << {
@@ -87,7 +99,8 @@ module Hind
       def has_declaration?(qualified_name)
         @classes.key?(qualified_name) ||
           @modules.key?(qualified_name) ||
-          @constants.key?(qualified_name)
+          @constants.key?(qualified_name) ||
+          @methods.key?(qualified_name)
       end
 
       def get_declaration(qualified_name)
@@ -95,8 +108,10 @@ module Hind
           determine_primary_class_definition(qualified_name)
         elsif @modules.key?(qualified_name)
           determine_primary_module_definition(qualified_name)
-        else
+        elsif @constants.key?(qualified_name)
           @constants[qualified_name]
+        else
+          @methods[qualified_name]
         end
       end
 
@@ -112,31 +127,48 @@ module Hind
         @ranges[file_path] || []
       end
 
-      def find_constant_declaration(name, current_scope)
-        # First check if the name exists exactly as provided
-        return name if has_declaration?(name)
-
-        return nil unless current_scope && !current_scope.empty?
+      def find_declaration(name, current_scope)
+        # Handle both constants (::) and methods (#)
+        is_method = name.start_with?('#')
+        sep = is_method ? '' : '::'
 
-        # Try with the full current scope
-        qualified_name = "#{current_scope}::#{name}"
+        # 1. Lexical Scope search
+        # Try full current scope
+        qualified_name = current_scope.empty? ? name : "#{current_scope}#{sep}#{name}"
+        # Strip leading # if simple name
+        qualified_name = name if current_scope.empty? && is_method
         return qualified_name if has_declaration?(qualified_name)
 
-        # Try with parent scopes by progressively removing the innermost scope
+        # 2. Ancestor chain search for current scope
+        if !current_scope.empty?
+          found = resolve_in_ancestors(name, current_scope, seen: Set.new)
+          return found if found
+        end
+
+        # 3. Parent Lexical Scopes
         scope_parts = current_scope.split('::')
         while scope_parts.size > 0
           scope_parts.pop
-          current_scope = scope_parts.join('::')
+          prefix = scope_parts.join('::')
 
-          # For empty scope, just check the name directly
-          qualified_name = current_scope.empty? ? name : "#{current_scope}::#{name}"
+          qualified_name = prefix.empty? ? name : "#{prefix}#{sep}#{name}"
+          qualified_name = name if prefix.empty? && is_method
           return qualified_name if has_declaration?(qualified_name)
+
+          # Search ancestors of the parent scope too
+          if !prefix.empty?
+            found = resolve_in_ancestors(name, prefix, seen: Set.new)
+            return found if found
+          end
         end
 
-        # Not found in any scope
         nil
       end
 
+      def find_constant_declaration(name, current_scope)
+        find_declaration(name, current_scope)
+      end
+
       def debug_info
         {
           classes_count: @classes.size,
@@ -247,6 +279,33 @@ module Hind
         # Rule 3: Fall back to the first definition
         definitions.first
       end
+
+      private
+
+      def resolve_in_ancestors(name, scope, seen:)
+        return nil if seen.include?(scope)
+        seen.add(scope)
+
+        is_method = name.start_with?('#')
+        sep = is_method ? '' : '::'
+
+        # Check this scope's ancestors
+        ancestors = @ancestors[scope] || []
+        ancestors.each do |ancestor|
+          mixed_in = ancestor[:name]
+          
+          # Try absolute name first (if it's already qualified)
+          qualified = "#{mixed_in}#{sep}#{name}"
+          qualified = name if mixed_in.empty? && is_method
+          return qualified if has_declaration?(qualified)
+
+          # Recurse into mixed_in's ancestors
+          found = resolve_in_ancestors(name, mixed_in, seen: seen)
+          return found if found
+        end
+
+        nil
+      end
     end
   end
 end

data/lib/hind/lsif/visitors/declaration_visitor.rb

@@ -59,6 +59,66 @@ module Hind
         super
       end
 
+      def visit_def_node(node)
+        method_name = node.name.to_s
+        qualified_name = @current_scope.empty? ? "##{method_name}" : "#{current_scope_name}##{method_name}"
+        
+        @generator.register_method_declaration({
+          type: :method,
+          name: qualified_name,
+          node: node,
+          scope: current_scope_name
+        })
+        super
+      end
+
+      def visit_call_node(node)
+        # Handle attr_accessor, attr_reader, attr_writer
+        if node.receiver.nil? && %w[attr_reader attr_writer attr_accessor].include?(node.name.to_s)
+          helpers = node.arguments&.arguments || []
+          helpers.each do |arg|
+            next unless arg.is_a?(Prism::SymbolNode)
+            
+            name = arg.value
+            if %w[attr_reader attr_accessor].include?(node.name.to_s)
+              # Getter
+              qualified_name = @current_scope.empty? ? "##{name}" : "#{current_scope_name}##{name}"
+              @generator.register_method_declaration({
+                type: :method,
+                name: qualified_name,
+                node: arg, # Use symbol node as the 'def' site
+                scope: current_scope_name
+              })
+            end
+
+            if %w[attr_writer attr_accessor].include?(node.name.to_s)
+              # Setter
+              setter_name = "#{name}="
+              qualified_name = @current_scope.empty? ? "##{setter_name}" : "#{current_scope_name}##{setter_name}"
+              @generator.register_method_declaration({
+                type: :method,
+                name: qualified_name,
+                node: arg,
+                scope: current_scope_name
+              })
+            end
+          end
+        end
+
+        # Handle include, extend, prepend
+        if node.receiver.nil? && %w[include extend prepend].include?(node.name.to_s)
+          modules = node.arguments&.arguments || []
+          modules.each do |mod_node|
+            # Simplified: only handle simple constant names or paths
+            next unless mod_node.is_a?(Prism::ConstantReadNode) || mod_node.is_a?(Prism::ConstantPathNode)
+            
+            mixed_in = mod_node.slice
+            GlobalState.instance.add_ancestor(current_scope_name, mixed_in, node.name.to_sym)
+          end
+        end
+        super
+      end
+
       private
 
       def current_scope_name

data/lib/hind/lsif/visitors/reference_visitor.rb

@@ -46,19 +46,96 @@ module Hind
       end
 
       def visit_class_node(node)
-        @current_scope.push(node.constant_path.slice)
+        @current_scope.push(scip_name(node.constant_path.slice))
         super
         @current_scope.pop
       end
 
       def visit_module_node(node)
-        @current_scope.push(node.constant_path.slice)
+        @current_scope.push(scip_name(node.constant_path.slice))
         super
         @current_scope.pop
       end
 
+      def visit_def_node(node)
+        # We don't push def to current_scope because methods are usually inside classes/modules
+        # and we use #method notation. Pushing 'method' to scope would result in A::B#method#submethod
+        # which is not standard for Ruby normally unless we handle nested blocks.
+        # But for now, let's just visit.
+        super
+      end
+
+      def visit_call_node(node)
+        # Speculative resolution for method calls
+        register_method_call_reference(node)
+        super
+      end
+
+      def visit_call_operator_write_node(node)
+        # Handle self.age += 1
+        # This involves both a getter (age) and a setter (age=)
+        register_method_call_reference(node, name_override: node.read_name.to_s)
+        register_method_call_reference(node, name_override: node.write_name.to_s)
+        super
+      end
+
+      def visit_call_and_write_node(node)
+        register_method_call_reference(node, name_override: node.read_name.to_s)
+        register_method_call_reference(node, name_override: node.write_name.to_s)
+        super
+      end
+
+      def visit_call_or_write_node(node)
+        register_method_call_reference(node, name_override: node.read_name.to_s)
+        register_method_call_reference(node, name_override: node.write_name.to_s)
+        super
+      end
+
+      def visit_index_operator_write_node(node)
+        # Handle obj[key] += val
+        register_method_call_reference(node, name_override: "[]")
+        register_method_call_reference(node, name_override: "[]=")
+        super
+      end
+
+      def visit_index_and_write_node(node)
+        register_method_call_reference(node, name_override: "[]")
+        register_method_call_reference(node, name_override: "[]=")
+        super
+      end
+
+      def visit_index_or_write_node(node)
+        register_method_call_reference(node, name_override: "[]")
+        register_method_call_reference(node, name_override: "[]=")
+        super
+      end
+
       private
 
+      def register_method_call_reference(node, name_override: nil)
+        method_name = name_override || node.name.to_s
+        
+        # Try finding #method_name in current scope
+        found_name = GlobalState.instance.find_declaration("##{method_name}", current_scope_name)
+        
+        if found_name
+          loc = node.respond_to?(:message_loc) ? (node.message_loc || node.location) : node.location
+          @generator.register_reference({
+            type: :method,
+            name: found_name,
+            node: node,
+            location: loc
+          })
+        end
+      end
+
+      def scip_name(name)
+        # Basic unescaping to match what we store in GlobalState keys if needed
+        # We store them unescaped in scope normally or with backticks if scip_name was used.
+        # Let's be consistent.
+        name.delete('`')
+      end
+
       def current_scope_name
         @current_scope.join('::')
       end

data/lib/hind/scip/generator.rb

@@ -280,17 +280,135 @@ module Hind
         end
 
         def visit_call_node(node)
-          return if @mode == :index
+          # Handle attr_accessor, attr_reader, attr_writer
+          index_attribute_helpers(node)
+          index_ancestor_helpers(node)
+
+          return super if @mode == :index
 
           # Skip common methods
           return super if %w[new puts p print].include?(node.name.to_s)
 
+          register_scip_call_reference(node)
+          super
+        end
+
+        def visit_call_operator_write_node(node)
+          return super if @mode == :index
+          register_scip_call_reference(node, name_override: node.read_name.to_s)
+          register_scip_call_reference(node, name_override: node.write_name.to_s)
+          super
+        end
+
+        def visit_call_and_write_node(node)
+          return super if @mode == :index
+          register_scip_call_reference(node, name_override: node.read_name.to_s)
+          register_scip_call_reference(node, name_override: node.write_name.to_s)
+          super
+        end
+
+        def visit_call_or_write_node(node)
+          return super if @mode == :index
+          register_scip_call_reference(node, name_override: node.read_name.to_s)
+          register_scip_call_reference(node, name_override: node.write_name.to_s)
+          super
+        end
+
+        def visit_index_operator_write_node(node)
+          return super if @mode == :index
+          register_scip_call_reference(node, name_override: "[]")
+          register_scip_call_reference(node, name_override: "[]=")
+          super
+        end
+
+        def visit_index_and_write_node(node)
+          return super if @mode == :index
+          register_scip_call_reference(node, name_override: "[]")
+          register_scip_call_reference(node, name_override: "[]=")
+          super
+        end
+
+        def visit_index_or_write_node(node)
+          return super if @mode == :index
+          register_scip_call_reference(node, name_override: "[]")
+          register_scip_call_reference(node, name_override: "[]=")
+          super
+        end
+
+        private
+
+        def index_attribute_helpers(node)
+          return unless node.receiver.nil? && %w[attr_reader attr_writer attr_accessor].include?(node.name.to_s)
+          
+          helpers = node.arguments&.arguments || []
+          helpers.each do |arg|
+            next unless arg.is_a?(Prism::SymbolNode)
+            
+            name = arg.value
+            if %w[attr_reader attr_accessor].include?(node.name.to_s)
+              # Getter
+              getter_name = scip_name(name)
+              qualified_name = "#{current_scope_name}##{name}"
+              suffix = @current_scope.empty? ? '' : '#'
+              symbol = "#{@package_prefix}#{@current_scope.join("#")}#{suffix}#{getter_name}."
+
+              if @mode == :index
+                GlobalState.instance.add_symbol(qualified_name, symbol)
+                GlobalState.instance.add_symbol("##{name}", symbol)
+              else
+                range = [arg.location.start_line - 1, arg.location.start_column, arg.location.end_column]
+                @occurrences << Occurrence.new(range: range, symbol: symbol, symbol_roles: 1, syntax_kind: SyntaxKind::Identifier)
+                unless GlobalState.instance.emitted?(symbol)
+                  @symbols << SymbolInformation.new(symbol: symbol, documentation: ["attr_reader #{name}"], kind: SymbolInformation::Kind::Method)
+                  GlobalState.instance.mark_emitted(symbol)
+                end
+              end
+            end
+
+            if %w[attr_writer attr_accessor].include?(node.name.to_s)
+              # Setter
+              setter_name = "#{name}="
+              escaped_setter = scip_name(setter_name)
+              qualified_name = "#{current_scope_name}##{setter_name}"
+              suffix = @current_scope.empty? ? '' : '#'
+              symbol = "#{@package_prefix}#{@current_scope.join("#")}#{suffix}#{escaped_setter}."
+
+              if @mode == :index
+                GlobalState.instance.add_symbol(qualified_name, symbol)
+                GlobalState.instance.add_symbol("##{setter_name}", symbol)
+              else
+                range = [arg.location.start_line - 1, arg.location.start_column, arg.location.end_column]
+                @occurrences << Occurrence.new(range: range, symbol: symbol, symbol_roles: 1, syntax_kind: SyntaxKind::Identifier)
+                unless GlobalState.instance.emitted?(symbol)
+                  @symbols << SymbolInformation.new(symbol: symbol, documentation: ["attr_writer #{name}"], kind: SymbolInformation::Kind::Method)
+                  GlobalState.instance.mark_emitted(symbol)
+                end
+              end
+            end
+          end
+        end
+
+        def index_ancestor_helpers(node)
+          return unless node.receiver.nil? && %w[include extend prepend].include?(node.name.to_s)
+          
+          modules = node.arguments&.arguments || []
+          modules.each do |mod_node|
+            next unless mod_node.is_a?(Prism::ConstantReadNode) || mod_node.is_a?(Prism::ConstantPathNode)
+            
+            mixed_in = mod_node.slice
+            GlobalState.instance.add_ancestor(current_scope_name, mixed_in)
+          end
+        end
+
+        def register_scip_call_reference(node, name_override: nil)
+          method_name = name_override || node.name.to_s
+          
           # Speculative resolution
-          symbol = GlobalState.instance.find_symbol("#{current_scope_name}##{node.name}", '') ||
-            GlobalState.instance.find_symbol("##{node.name}", '')
+          symbol = GlobalState.instance.find_symbol("#{current_scope_name}##{method_name}", '') ||
+            GlobalState.instance.find_symbol("##{method_name}", '')
 
           if symbol
-            loc = node.message_loc || node.location
+            loc = node.respond_to?(:message_loc) ? (node.message_loc || node.location) : node.location
             range = [
               loc.start_line - 1,
               loc.start_column,
@@ -304,7 +422,6 @@ module Hind
               syntax_kind: SyntaxKind::Identifier
             )
           end
-          super
         end
 
         private

data/lib/hind/scip/global_state.rb

@@ -14,9 +14,15 @@ module Hind
 
       def reset
         @symbols = {} # {qualified_name => symbol_string}
+        @ancestors = {} # {qualified_name => [symbol_strings]}
         @emitted_symbols = Set.new
       end
 
+      def add_ancestor(qualified_name, mixed_in_symbol)
+        @ancestors[qualified_name] ||= []
+        @ancestors[qualified_name] << mixed_in_symbol
+      end
+
       def mark_emitted(symbol)
         @emitted_symbols.add(symbol)
       end
@@ -38,20 +44,59 @@ module Hind
       end
 
       def find_symbol(name, current_scope)
-        # Reuse LSIF-like scope resolution logic
-        return @symbols[name] if @symbols.key?(name)
+        # Handle both constants (::) and methods (#)
+        is_method = name.start_with?('#')
+        sep = is_method ? '' : '::'
 
-        return nil unless current_scope && !current_scope.empty?
-
-        qualified_name = "#{current_scope}::#{name}"
+        # 1. Lexical Scope search
+        qualified_name = current_scope.empty? ? name : "#{current_scope}#{sep}#{name}"
+        qualified_name = name if current_scope.empty? && is_method
         return @symbols[qualified_name] if @symbols.key?(qualified_name)
 
+        # 2. Ancestor chain search for current scope
+        if !current_scope.empty?
+          found = resolve_in_ancestors(name, current_scope, seen: Set.new)
+          return found if found
+        end
+
+        # 3. Parent Lexical Scopes
         scope_parts = current_scope.split('::')
         while scope_parts.size > 0
           scope_parts.pop
           prefix = scope_parts.join('::')
-          qualified_name = prefix.empty? ? name : "#{prefix}::#{name}"
+
+          qualified_name = prefix.empty? ? name : "#{prefix}#{sep}#{name}"
+          qualified_name = name if prefix.empty? && is_method
           return @symbols[qualified_name] if @symbols.key?(qualified_name)
+
+          # Search ancestors of the parent scope too
+          if !prefix.empty?
+            found = resolve_in_ancestors(name, prefix, seen: Set.new)
+            return found if found
+          end
+        end
+
+        nil
+      end
+
+      private
+
+      def resolve_in_ancestors(name, scope, seen:)
+        return nil if seen.include?(scope)
+        seen.add(scope)
+
+        is_method = name.start_with?('#')
+        sep = is_method ? '' : '::'
+
+        ancestors = @ancestors[scope] || []
+        ancestors.each do |mixed_in|
+          # 1. Try to see if mixed_in has the declaration
+          qualified = "#{mixed_in}#{sep}#{name}"
+          return @symbols[qualified] if @symbols.key?(qualified)
+
+          # 2. Recurse into mixed_in's ancestors
+          found = resolve_in_ancestors(name, mixed_in, seen: seen)
+          return found if found
         end
 
         nil

data/lib/hind/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hind
-  VERSION = '0.1.17'
+  VERSION = '0.1.18'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hind
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.18
 platform: ruby
 authors:
 - Aboobacker MK