hind 0.1.6 → 0.1.8

data/lib/hind/lsif/global_state.rb

@@ -13,10 +13,6 @@ module Hind
         @result_sets = {}     # {qualified_name => result_set_id}
         @ranges = {}          # {file_path => [range_ids]}
         @project_id = nil
-
-        # Method visibility tracking
-        @visibility_stack = [] # Stack of method visibility states per scope
-        @current_visibility = :public
       end
 
       def add_declaration(qualified_name, data)
@@ -24,12 +20,12 @@ module Hind
         @result_sets[qualified_name] = data[:result_set_id] if data[:result_set_id]
       end
 
-      def add_reference(qualified_name, file_path, range_id, type = :reference)
+      def add_reference(qualified_name, file_path, range_id, document_id)
         @references[qualified_name] ||= []
         @references[qualified_name] << {
           file: file_path,
           range_id: range_id,
-          type: type
+          document_id: document_id
         }
       end
 
@@ -58,98 +54,31 @@ module Hind
         @ranges[file_path] || []
       end
 
-      def push_visibility_scope(visibility = :public)
-        @visibility_stack.push(@current_visibility)
-        @current_visibility = visibility
-      end
-
-      def pop_visibility_scope
-        @current_visibility = @visibility_stack.pop || :public
-      end
-
-      def current_visibility
-        @current_visibility
-      end
-
-      def get_declaration_in_scope(name, scope)
-        # Try exact scope first
-        qualified_name = scope.empty? ? name : "#{scope}::#{name}"
-        return qualified_name if has_declaration?(qualified_name)
-
-        # Try parent scopes
-        scope_parts = scope.split('::')
-        while scope_parts.any?
-          scope_parts.pop
-          qualified_name = scope_parts.empty? ? name : "#{scope_parts.join('::')}::#{name}"
-          return qualified_name if has_declaration?(qualified_name)
-        end
-
-        # Try top level
-        has_declaration?(name) ? name : nil
-      end
-
-      def get_method_declaration(method_name, scope, instance_method = true)
-        separator = instance_method ? '#' : '.'
-        qualified_name = scope.empty? ? method_name : "#{scope}#{separator}#{method_name}"
-
-        return qualified_name if has_declaration?(qualified_name)
-
-        # For instance methods, try to find in superclass chain
-        if instance_method && !scope.empty?
-          current_scope = scope
-          while (class_data = @declarations[current_scope])
-            break unless class_data[:type] == :class && class_data[:superclass]
-
-            superclass = class_data[:superclass]
-            superclass_method = "#{superclass}#{separator}#{method_name}"
-            return superclass_method if has_declaration?(superclass_method)
-
-            current_scope = superclass
-          end
-        end
-
-        nil
-      end
-
       def find_constant_declaration(name, current_scope)
         return name if has_declaration?(name)
 
-        # Try with current scope
         if current_scope && !current_scope.empty?
           qualified_name = "#{current_scope}::#{name}"
           return qualified_name if has_declaration?(qualified_name)
 
-          # Try parent scopes
           scope_parts = current_scope.split('::')
           while scope_parts.any?
             scope_parts.pop
-            qualified_name = scope_parts.empty? ? name : "#{scope_parts.join('::')}::#{name}"
+            qualified_name = scope_parts.empty? ? name : "#{scope_parts.join("::")}::#{name}"
             return qualified_name if has_declaration?(qualified_name)
           end
         end
 
-        # Try top level
         has_declaration?(name) ? name : nil
       end
 
-      def get_instance_variable_scope(var_name, current_scope)
-        return nil unless current_scope
-        "#{current_scope}##{var_name}"
-      end
-
-      def get_class_variable_scope(var_name, current_scope)
-        return nil unless current_scope
-        "#{current_scope}::#{var_name}"
-      end
-
       def debug_info
         {
           declarations_count: @declarations.size,
           references_count: @references.values.sum(&:size),
           result_sets_count: @result_sets.size,
           ranges_count: @ranges.values.sum(&:size),
-          declaration_types: declaration_types_count,
-          reference_types: reference_types_count
+          declaration_types: declaration_types_count
         }
       end
 
@@ -160,12 +89,6 @@ module Hind
           counts[decl[:type]] += 1
         end
       end
-
-      def reference_types_count
-        @references.values.flatten.each_with_object(Hash.new(0)) do |ref, counts|
-          counts[ref[:type]] += 1
-        end
-      end
     end
   end
 end

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

@@ -10,16 +10,12 @@ module Hind
         @generator = generator
         @file_path = file_path
         @current_scope = []
-        @current_visibility = :public
-        @visibility_stack = []
-        @in_singleton_class = false
       end
 
       def visit_class_node(node)
         @current_scope.push(node.constant_path.slice)
         class_name = current_scope_name
 
-        # Register class declaration
         @generator.register_declaration({
           type: :class,
           name: class_name,
@@ -28,10 +24,7 @@ module Hind
           superclass: node.superclass&.slice
         })
 
-        # Process the class body with proper scope and visibility
-        push_visibility(:public)
         super
-        pop_visibility
         @current_scope.pop
       end
 
@@ -46,32 +39,10 @@ module Hind
           scope: @current_scope[0..-2].join('::')
         })
 
-        push_visibility(:public)
         super
-        pop_visibility
         @current_scope.pop
       end
 
-      def visit_def_node(node)
-        method_name = node.name.to_s
-        # Use '#' for instance methods
-        qualified_name = @in_singleton_class ?
-          "#{current_scope_name}.#{method_name}" :
-          "#{current_scope_name}##{method_name}"
-
-        @generator.register_declaration({
-          type: :method,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name,
-          visibility: current_visibility,
-          params: node.parameters&.slice,
-          instance_method: !@in_singleton_class
-        })
-
-        super
-      end
-
       def visit_constant_write_node(node)
         return unless node.name
 
@@ -88,152 +59,11 @@ module Hind
         super
       end
 
-      def visit_singleton_class_node(node)
-        if node.expression.is_a?(Prism::SelfNode)
-          # class << self
-          @in_singleton_class = true
-          super
-          @in_singleton_class = false
-        else
-          # Process regular singleton class
-          super
-        end
-      end
-
-      def visit_call_node(node)
-        method_name = node.name.to_s
-        case method_name
-        when 'private', 'protected', 'public'
-          handle_visibility_method(node)
-        when 'attr_reader', 'attr_writer', 'attr_accessor'
-          handle_attribute_method(node)
-        end
-
-        super
-      end
-
-      def visit_class_variable_write_node(node)
-        return unless node.name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}::#{var_name}"
-
-        @generator.register_declaration({
-          type: :class_variable,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name
-        })
-
-        super
-      end
-
-      def visit_instance_variable_write_node(node)
-        return unless node.name && current_scope_name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}##{var_name}"
-
-        @generator.register_declaration({
-          type: :instance_variable,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name
-        })
-
-        super
-      end
-
       private
 
       def current_scope_name
         @current_scope.join('::')
       end
-
-      def current_visibility
-        @current_visibility
-      end
-
-      def push_visibility(visibility)
-        @visibility_stack.push(@current_visibility)
-        @current_visibility = visibility
-      end
-
-      def pop_visibility
-        @current_visibility = @visibility_stack.pop || :public
-      end
-
-      def handle_visibility_method(node)
-        visibility = node.name.to_sym
-
-        if node.arguments&.arguments&.empty?
-          # Global visibility change
-          @current_visibility = visibility
-        elsif node.arguments
-          # Per-method visibility change
-          node.arguments.arguments.each do |arg|
-            next unless arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
-
-            method_name = arg.value.to_s
-            qualified_name = "#{current_scope_name}##{method_name}"
-
-            if @generator.global_state.has_declaration?(qualified_name)
-              @generator.global_state.get_declaration(qualified_name)[:visibility] = visibility
-            end
-          end
-        end
-      end
-
-      def handle_attribute_method(node)
-        return unless node.arguments
-
-        attr_type = node.name.to_s
-        node.arguments.arguments.each do |arg|
-          next unless arg.respond_to?(:value)
-
-          attr_name = arg.value.to_s
-          register_attribute(attr_name, attr_type)
-        end
-      end
-
-      def register_attribute(attr_name, attr_type)
-        base_name = "#{current_scope_name}##{attr_name}"
-
-        # Register reader method if applicable
-        if %w[attr_reader attr_accessor].include?(attr_type)
-          @generator.register_declaration({
-            type: :method,
-            name: base_name,
-            node: nil, # Synthetic node
-            scope: current_scope_name,
-            visibility: current_visibility,
-            synthetic: true,
-            kind: :reader
-          })
-        end
-
-        # Register writer method if applicable
-        if %w[attr_writer attr_accessor].include?(attr_type)
-          @generator.register_declaration({
-            type: :method,
-            name: "#{base_name}=",
-            node: nil, # Synthetic node
-            scope: current_scope_name,
-            visibility: current_visibility,
-            synthetic: true,
-            kind: :writer
-          })
-        end
-
-        # Register the instance variable
-        @generator.register_declaration({
-          type: :instance_variable,
-          name: "@#{attr_name}",
-          node: nil, # Synthetic node
-          scope: current_scope_name,
-          synthetic: true
-        })
-      end
     end
   end
 end

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

@@ -1,4 +1,3 @@
-# lib/hind/lsif/visitors/reference_visitor.rb
 # frozen_string_literal: true
 
 module Hind
@@ -12,27 +11,6 @@ module Hind
         @current_scope = []
       end
 
-      # Method calls
-      def visit_call_node(node)
-        return unless node.name && node.location
-
-        method_name = node.name.to_s
-        qualified_names = generate_qualified_names_for_call(node)
-
-        qualified_names.each do |qualified_name|
-          @generator.register_reference({
-            type: :method,
-            name: qualified_name,
-            node: node,
-            scope: current_scope_name,
-            call_type: :instance_method
-          })
-        end
-
-        super
-      end
-
-      # Class/module references
       def visit_constant_read_node(node)
         return unless node.name
 
@@ -49,7 +27,6 @@ module Hind
         super
       end
 
-      # Constant path references (e.g., A::B::C)
       def visit_constant_path_node(node)
         qualified_name = node.slice
 
@@ -63,87 +40,6 @@ module Hind
         super
       end
 
-      # Instance variable references
-      def visit_instance_variable_read_node(node)
-        return unless node.name && current_scope_name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}##{var_name}"
-
-        @generator.register_reference({
-          type: :instance_variable,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name
-        })
-
-        super
-      end
-
-      # Class variable references
-      def visit_class_variable_read_node(node)
-        return unless node.name && current_scope_name
-
-        var_name = node.name.to_s
-        qualified_name = "#{current_scope_name}::#{var_name}"
-
-        @generator.register_reference({
-          type: :class_variable,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name
-        })
-
-        super
-      end
-
-      # Singleton method calls (class methods)
-      def visit_constant_path_call_node(node)
-        return unless node.name
-
-        method_name = node.name.to_s
-        receiver_name = node.receiver.slice
-        qualified_name = "#{receiver_name}.#{method_name}"
-
-        @generator.register_reference({
-          type: :method,
-          name: qualified_name,
-          node: node,
-          scope: current_scope_name,
-          call_type: :class_method
-        })
-
-        super
-      end
-
-      # Super method calls
-      def visit_super_node(node)
-        return unless current_scope_name
-
-        # Extract current method name from scope
-        current_method = current_method_name
-        return unless current_method
-
-        # Try to find the superclass method
-        if in_class_scope?
-          superclass = find_superclass
-          if superclass
-            qualified_name = "#{superclass}##{current_method}"
-
-            @generator.register_reference({
-              type: :method,
-              name: qualified_name,
-              node: node,
-              scope: current_scope_name,
-              call_type: :super
-            })
-          end
-        end
-
-        super
-      end
-
-      # Track class/module scope
       def visit_class_node(node)
         @current_scope.push(node.constant_path.slice)
         super
@@ -161,61 +57,6 @@ module Hind
       def current_scope_name
         @current_scope.join('::')
       end
-
-      def generate_qualified_names_for_call(node)
-        qualified_names = []
-        method_name = node.name.to_s
-
-        # Try with current scope first
-        qualified_names << "#{current_scope_name}##{method_name}" unless current_scope_name.empty?
-
-        # Try with receiver's type if available
-        if node.receiver
-          case node.receiver
-          when Prism::ConstantReadNode
-            qualified_names << "#{node.receiver.name}##{method_name}"
-          when Prism::ConstantPathNode
-            qualified_names << "#{node.receiver.slice}##{method_name}"
-          when Prism::CallNode
-            # Method chaining - try both instance and class methods
-            if node.receiver.name
-              qualified_names << "#{node.receiver.name}##{method_name}"
-              qualified_names << "#{node.receiver.name}.#{method_name}"
-            end
-          when Prism::InstanceVariableReadNode
-            # Instance variable calls - try current class context
-            qualified_names << "#{current_scope_name}##{method_name}" if current_scope_name
-          end
-        end
-
-        # Try as a standalone method
-        qualified_names << method_name
-
-        # Add potential class method variant
-        qualified_names << "#{current_scope_name}.#{method_name}" unless current_scope_name.empty?
-
-        qualified_names.uniq
-      end
-
-      def current_method_name
-        # Try to find the nearest method node in the AST
-        # This is a simplified version - you might need to enhance this
-        # based on your specific needs
-        "current_method"
-      end
-
-      def in_class_scope?
-        # Check if we're currently in a class definition
-        !@current_scope.empty? && @generator.global_state.declarations[@current_scope.last]&.[](:type) == :class
-      end
-
-      def find_superclass
-        return unless in_class_scope?
-
-        current_class = @current_scope.last
-        class_declaration = @generator.global_state.declarations[current_class]
-        class_declaration&.[](:superclass)
-      end
     end
   end
 end

data/lib/hind/lsif.rb

@@ -4,7 +4,6 @@ require_relative 'lsif/global_state'
 require_relative 'lsif/edge'
 require_relative 'lsif/generator'
 require_relative 'lsif/vertex'
-require_relative 'lsif/visitor'
 
 module Hind
   module LSIF

data/lib/hind/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hind
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Aboobacker MK
@@ -111,7 +111,6 @@ files:
 - lib/hind/lsif/generator.rb
 - lib/hind/lsif/global_state.rb
 - lib/hind/lsif/vertex.rb
-- lib/hind/lsif/visitor.rb
 - lib/hind/lsif/visitors/declaration_visitor.rb
 - lib/hind/lsif/visitors/reference_visitor.rb
 - lib/hind/parser.rb