hind 0.1.4 → 0.1.6

data/lib/hind/lsif/visitor.rb

@@ -1,29 +1,168 @@
+# 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
+      def visit_def_node(node)
+        method_name = node.name.to_s
+        qualified_name = current_scope_name.empty? ? method_name : "#{current_scope_name}##{method_name}"
+
+        range_id = @generator.create_range(node.location, node.location)
+        result_set_id = @generator.emit_vertex('resultSet')
+        @generator.emit_edge('next', range_id, result_set_id)
+
+        def_result_id = @generator.emit_vertex('definitionResult')
+        @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
+        @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
+
+        # Generate method signature for hover
+        sig = []
+        sig << "def #{qualified_name}"
+        sig << "(#{node.parameters.slice})" if node.parameters
 
-        method_name = "visit_#{node.class.name.split('::').last.downcase}"
-        if respond_to?(method_name)
-          send(method_name, node)
+        hover_id = @generator.emit_vertex('hoverResult', {
+          contents: [{
+            language: 'ruby',
+            value: sig.join
+          }]
+        })
+        @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
+
+        @generator.add_to_global_state(qualified_name, result_set_id, range_id)
+
+        super
+      end
+
+      def visit_class_node(node)
+        @current_scope.push(node.constant_path.slice)
+        class_name = current_scope_name
+
+        range_id = @generator.create_range(node.location, node.location)
+        result_set_id = @generator.emit_vertex('resultSet')
+        @generator.emit_edge('next', range_id, result_set_id)
+
+        def_result_id = @generator.emit_vertex('definitionResult')
+        @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
+        @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
+
+        # Generate hover with inheritance info
+        hover = []
+        class_def = "class #{class_name}"
+        class_def += " < #{node.superclass.slice}" if node.superclass
+
+        hover << if node.superclass
+          "#{class_def}\n\nInherits from: #{node.superclass.slice}"
         else
-          visit_children(node)
+          class_def
         end
+
+        hover_id = @generator.emit_vertex('hoverResult', {
+          contents: [{
+            language: 'ruby',
+            value: hover.join("\n")
+          }]
+        })
+        @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
+
+        @generator.add_to_global_state(class_name, result_set_id, range_id)
+
+        # Handle inheritance
+        visit_inheritance(node.superclass) if node.superclass
+
+        super
+        @current_scope.pop
       end
 
-      def visit_children(node)
-        node.child_nodes.each { |child| visit(child) if child }
+      def visit_module_node(node)
+        @current_scope.push(node.constant_path.slice)
+        module_name = current_scope_name
+
+        range_id = @generator.create_range(node.location, node.location)
+        result_set_id = @generator.emit_vertex('resultSet')
+        @generator.emit_edge('next', range_id, result_set_id)
+
+        def_result_id = @generator.emit_vertex('definitionResult')
+        @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
+        @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
+
+        hover_id = @generator.emit_vertex('hoverResult', {
+          contents: [{
+            language: 'ruby',
+            value: "module #{module_name}"
+          }]
+        })
+        @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
+
+        @generator.add_to_global_state(module_name, result_set_id, range_id)
+
+        super
+        @current_scope.pop
       end
 
-      def visit_defnode(node)
+      def visit_call_node(node)
+        return unless node.name && node.location
+
         method_name = node.name.to_s
-        qualified_name = current_scope_name.empty? ? method_name : "#{current_scope_name}##{method_name}"
+        qualified_names = []
+
+        # 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.type
+          when :constant_read
+            qualified_names << "#{node.receiver.name}##{method_name}"
+          when :call
+            # Handle method chaining
+            qualified_names << "#{node.receiver.name}##{method_name}" if node.receiver.name
+          when :instance_variable_read
+            # Handle instance variable calls
+            qualified_names << "#{current_scope_name}##{method_name}" if current_scope_name
+          end
+        end
+
+        # Try as a standalone method
+        qualified_names << method_name
+
+        # Add references for matching qualified names
+        qualified_names.each do |qualified_name|
+          next unless @generator.global_state.result_sets[qualified_name]
+
+          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])
+          break # Stop after finding first match
+        end
+
+        super
+      end
+
+      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}"
+
+        return unless @generator.global_state.result_sets[qualified_name]
+
+        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_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}"
 
         range_id = @generator.create_range(node.location, node.location)
         result_set_id = @generator.emit_vertex('resultSet')
@@ -33,31 +172,84 @@ module Hind
         @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
         @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
 
-        # Add hover information
-        sig = []
-        sig << "def #{qualified_name}"
-        sig << "(#{node.parameters.slice})" if node.parameters
-
         hover_id = @generator.emit_vertex('hoverResult', {
           contents: [{
             language: 'ruby',
-            value: sig.join
+            value: "#{qualified_name} = ..."
           }]
         })
         @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
 
         @generator.add_to_global_state(qualified_name, result_set_id, range_id)
 
-        visit_children(node)
+        super
+      end
+
+      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}"
+
+        return unless @generator.global_state.result_sets[qualified_name]
+
+        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
 
-      # Additional visitor methods...
+      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}"
+
+        range_id = @generator.create_range(node.location, node.location)
+        result_set_id = @generator.emit_vertex('resultSet')
+        @generator.emit_edge('next', range_id, result_set_id)
+
+        def_result_id = @generator.emit_vertex('definitionResult')
+        @generator.emit_edge('textDocument/definition', result_set_id, def_result_id)
+        @generator.emit_edge('item', def_result_id, [range_id], 'definitions')
+
+        hover_id = @generator.emit_vertex('hoverResult', {
+          contents: [{
+            language: 'ruby',
+            value: "Instance variable #{var_name} in #{current_scope_name}"
+          }]
+        })
+        @generator.emit_edge('textDocument/hover', result_set_id, hover_id)
+
+        @generator.add_to_global_state(qualified_name, result_set_id, range_id)
+
+        super
+      end
 
       private
 
       def current_scope_name
         @current_scope.join('::')
       end
+
+      def visit_inheritance(node)
+        case node.type
+        when :constant_read_node, :constant_path_node
+          range_id = @generator.create_range(node.location, node.location)
+          qualified_name = case node.type
+          when :constant_read_node
+            node.name.to_s
+          when :constant_path_node
+            node.slice
+          end
+
+          return unless @generator.global_state.result_sets[qualified_name]
+
+          @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])
+        end
+      end
     end
   end
 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