hind 0.1.5 → 0.1.6

data/lib/hind/lsif/visitor.rb

@@ -1,31 +1,14 @@
-# lib/hind/lsif/visitor.rb
 # frozen_string_literal: true
 
 module Hind
   module LSIF
-    class Visitor
+    class Visitor < Prism::Visitor
       def initialize(generator)
         @generator = generator
         @current_scope = []
       end
 
-      def visit(node)
-        return unless node
-
-        method_name = "visit_#{node.class.name.split("::").last.downcase}"
-        if respond_to?(method_name)
-          send(method_name, node)
-        else
-          visit_children(node)
-        end
-      end
-
-      def visit_children(node)
-        node.child_nodes.each { |child| visit(child) if child }
-      end
-
-      def visit_defnode(node)
-        # Handle method definitions
+      def visit_def_node(node)
         method_name = node.name.to_s
         qualified_name = current_scope_name.empty? ? method_name : "#{current_scope_name}##{method_name}"
 
@@ -52,10 +35,10 @@ module Hind
 
         @generator.add_to_global_state(qualified_name, result_set_id, range_id)
 
-        visit_children(node)
+        super
       end
 
-      def visit_classnode(node)
+      def visit_class_node(node)
         @current_scope.push(node.constant_path.slice)
         class_name = current_scope_name
 
@@ -91,11 +74,11 @@ module Hind
         # Handle inheritance
         visit_inheritance(node.superclass) if node.superclass
 
-        visit_children(node)
+        super
         @current_scope.pop
       end
 
-      def visit_modulenode(node)
+      def visit_module_node(node)
         @current_scope.push(node.constant_path.slice)
         module_name = current_scope_name
 
@@ -117,11 +100,11 @@ module Hind
 
         @generator.add_to_global_state(module_name, result_set_id, range_id)
 
-        visit_children(node)
+        super
         @current_scope.pop
       end
 
-      def visit_callnode(node)
+      def visit_call_node(node)
         return unless node.name && node.location
 
         method_name = node.name.to_s
@@ -132,13 +115,13 @@ module Hind
 
         # Try with receiver's type if available
         if node.receiver
-          case node.receiver
-          when Prism::ConstantReadNode
+          case node.receiver.type
+          when :constant_read
             qualified_names << "#{node.receiver.name}##{method_name}"
-          when Prism::CallNode
+          when :call
             # Handle method chaining
             qualified_names << "#{node.receiver.name}##{method_name}" if node.receiver.name
-          when Prism::InstanceVariableReadNode
+          when :instance_variable_read
             # Handle instance variable calls
             qualified_names << "#{current_scope_name}##{method_name}" if current_scope_name
           end
@@ -157,10 +140,10 @@ module Hind
           break # Stop after finding first match
         end
 
-        visit_children(node)
+        super
       end
 
-      def visit_constantreadnode(node)
+      def visit_constant_read_node(node)
         return unless node.name
 
         constant_name = node.name.to_s
@@ -171,9 +154,11 @@ module Hind
         range_id = @generator.create_range(node.location, node.location)
         @generator.global_state.add_reference(qualified_name, @generator.metadata[:uri], range_id)
         @generator.emit_edge('next', range_id, @generator.global_state.result_sets[qualified_name])
+
+        super
       end
 
-      def visit_constantwritenode(node)
+      def visit_constant_write_node(node)
         return unless node.name
 
         constant_name = node.name.to_s
@@ -197,10 +182,10 @@ module Hind
 
         @generator.add_to_global_state(qualified_name, result_set_id, range_id)
 
-        visit_children(node)
+        super
       end
 
-      def visit_instancevariablereadnode(node)
+      def visit_instance_variable_read_node(node)
         return unless node.name && current_scope_name
 
         var_name = node.name.to_s
@@ -211,9 +196,11 @@ module Hind
         range_id = @generator.create_range(node.location, node.location)
         @generator.global_state.add_reference(qualified_name, @generator.metadata[:uri], range_id)
         @generator.emit_edge('next', range_id, @generator.global_state.result_sets[qualified_name])
+
+        super
       end
 
-      def visit_instancevariablewritenode(node)
+      def visit_instance_variable_write_node(node)
         return unless node.name && current_scope_name
 
         var_name = node.name.to_s
@@ -237,7 +224,7 @@ module Hind
 
         @generator.add_to_global_state(qualified_name, result_set_id, range_id)
 
-        visit_children(node)
+        super
       end
 
       private
@@ -247,13 +234,13 @@ module Hind
       end
 
       def visit_inheritance(node)
-        case node
-        when Prism::ConstantReadNode, Prism::ConstantPathNode
+        case node.type
+        when :constant_read_node, :constant_path_node
           range_id = @generator.create_range(node.location, node.location)
-          qualified_name = case node
-          when Prism::ConstantReadNode
+          qualified_name = case node.type
+          when :constant_read_node
             node.name.to_s
-          when Prism::ConstantPathNode
+          when :constant_path_node
             node.slice
           end
 

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

@@ -0,0 +1,239 @@
+# lib/hind/lsif/visitors/declaration_visitor.rb
+# frozen_string_literal: true
+
+module Hind
+  module LSIF
+    class DeclarationVisitor < Prism::Visitor
+      attr_reader :current_scope
+
+      def initialize(generator, file_path)
+        @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,
+          node: node,
+          scope: @current_scope[0..-2].join('::'),
+          superclass: node.superclass&.slice
+        })
+
+        # Process the class body with proper scope and visibility
+        push_visibility(:public)
+        super
+        pop_visibility
+        @current_scope.pop
+      end
+
+      def visit_module_node(node)
+        @current_scope.push(node.constant_path.slice)
+        module_name = current_scope_name
+
+        @generator.register_declaration({
+          type: :module,
+          name: module_name,
+          node: node,
+          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
+
+        constant_name = node.name.to_s
+        qualified_name = @current_scope.empty? ? constant_name : "#{current_scope_name}::#{constant_name}"
+
+        @generator.register_declaration({
+          type: :constant,
+          name: qualified_name,
+          node: node,
+          scope: current_scope_name
+        })
+
+        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

@@ -0,0 +1,221 @@
+# lib/hind/lsif/visitors/reference_visitor.rb
+# frozen_string_literal: true
+
+module Hind
+  module LSIF
+    class ReferenceVisitor < Prism::Visitor
+      attr_reader :current_scope
+
+      def initialize(generator, file_path)
+        @generator = generator
+        @file_path = file_path
+        @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
+
+        constant_name = node.name.to_s
+        qualified_name = @current_scope.empty? ? constant_name : "#{current_scope_name}::#{constant_name}"
+
+        @generator.register_reference({
+          type: :constant,
+          name: qualified_name,
+          node: node,
+          scope: current_scope_name
+        })
+
+        super
+      end
+
+      # Constant path references (e.g., A::B::C)
+      def visit_constant_path_node(node)
+        qualified_name = node.slice
+
+        @generator.register_reference({
+          type: :constant,
+          name: qualified_name,
+          node: node,
+          scope: current_scope_name
+        })
+
+        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
+        @current_scope.pop
+      end
+
+      def visit_module_node(node)
+        @current_scope.push(node.constant_path.slice)
+        super
+        @current_scope.pop
+      end
+
+      private
+
+      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/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hind
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Aboobacker MK
 bindir: exe
 cert_chain: []
-date: 2025-02-09 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -112,6 +112,8 @@ files:
 - 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
 - lib/hind/scip.rb
 - lib/hind/scip/generator.rb