hind 0.1.5 → 0.1.6

data/lib/hind/lsif/generator.rb

@@ -3,79 +3,159 @@
 require 'prism'
 require 'json'
 require 'uri'
+require 'pathname'
+
+require_relative 'visitors/declaration_visitor'
+require_relative 'visitors/reference_visitor'
 
 module Hind
   module LSIF
     class Generator
       LSIF_VERSION = '0.4.3'
 
-      attr_reader :global_state, :document_id, :metadata
+      attr_reader :metadata, :global_state, :document_id, :current_uri
 
-      def initialize(metadata = {}, global_state = nil)
+      def initialize(metadata = {})
         @vertex_id = metadata[:vertex_id] || 1
         @metadata = {
           language: 'ruby',
-          projectRoot: Dir.pwd
+          projectRoot: File.expand_path(metadata[:projectRoot] || Dir.pwd)
         }.merge(metadata)
 
-        @global_state = global_state || GlobalState.new
+        @global_state = GlobalState.new
         @document_ids = {}
         @lsif_data = []
+        @current_uri = nil
 
         initialize_project if metadata[:initial]
       end
 
-      def generate(code, file_metadata = {})
-        @metadata = @metadata.merge(file_metadata)
+      def collect_declarations(files)
+        files.each do |path, content|
+          @current_uri = path
+          ast = Parser.new(content).parse
+          visitor = DeclarationVisitor.new(self, path)
+          visitor.visit(ast)
+        end
+
+        { declarations: @global_state.declarations }
+      end
+
+      def process_file(params)
+        content = params[:content]
+        @current_uri = params[:uri]
+
         setup_document
+        ast = Parser.new(content).parse
 
-        ast = Parser.new(code).parse
-        visitor = Visitor.new(self)
+        # Process declarations first to update any missing ones
+        visitor = DeclarationVisitor.new(self, @current_uri)
         visitor.visit(ast)
 
-        finalize_document
-        update_cross_file_references
+        # Then process references
+        visitor = ReferenceVisitor.new(self, @current_uri)
+        visitor.visit(ast)
 
+        finalize_document
         @lsif_data
       end
 
-      def create_range(start_location, end_location)
-        range_id = emit_vertex('range', {
-          start: {
-            line: start_location.start_line - 1,
-            character: start_location.start_column
-          },
-          end: {
-            line: end_location.end_line - 1,
-            character: end_location.end_column
-          }
-        })
+      def register_declaration(declaration)
+        return unless @current_uri && declaration[:node]
 
-        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
-        @global_state.add_range(file_path, range_id)
-        range_id
-      end
+        qualified_name = declaration[:name]
+        range_id = create_range(declaration[:node].location, declaration[:node].location)
+        return unless range_id
 
-      def emit_vertex(label, data = nil)
-        vertex = Vertex.new(@vertex_id, label, data)
-        @lsif_data << vertex.to_json
-        @vertex_id += 1
-        @vertex_id - 1
+        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')
+
+        hover_content = generate_hover_content(declaration)
+        hover_id = emit_vertex('hoverResult', {
+          contents: [{
+            language: 'ruby',
+            value: hover_content
+          }]
+        })
+        emit_edge('textDocument/hover', result_set_id, hover_id)
+
+        @global_state.add_declaration(qualified_name, {
+          type: declaration[:type],
+          scope: declaration[:scope],
+          file: @current_uri,
+          range_id: range_id,
+          result_set_id: result_set_id
+        }.merge(declaration))
       end
 
-      def emit_edge(label, out_v, in_v, property = nil)
-        return unless out_v && valid_in_v?(in_v)
+      def register_reference(reference)
+        return unless @current_uri && reference[:node]
+        return unless @global_state.has_declaration?(reference[:name])
 
-        edge = Edge.new(@vertex_id, label, out_v, in_v, property, edge_document(label))
-        @lsif_data << edge.to_json
-        @vertex_id += 1
-        @vertex_id - 1
+        range_id = create_range(reference[:node].location, reference[:node].location)
+        return unless range_id
+
+        declaration = @global_state.declarations[reference[:name]]
+        @global_state.add_reference(reference[:name], @current_uri, range_id)
+        emit_edge('next', range_id, declaration[:result_set_id])
       end
 
-      def add_to_global_state(qualified_name, result_set_id, range_id)
-        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
-        @global_state.result_sets[qualified_name] = result_set_id
-        @global_state.add_definition(qualified_name, file_path, range_id)
+      def finalize_cross_references
+        cross_ref_data = []
+
+        @global_state.references.each do |qualified_name, references|
+          declaration = @global_state.declarations[qualified_name]
+          next unless declaration
+
+          result_set_id = declaration[:result_set_id]
+          next unless result_set_id
+
+          ref_result_id = emit_vertex('referenceResult')
+          emit_edge('textDocument/references', result_set_id, ref_result_id)
+
+          # Collect all reference range IDs
+          all_refs = references.map { |ref| ref[:range_id] }
+          all_refs << declaration[:range_id] if declaration[:range_id]
+
+          # Group references by document
+          references.group_by { |ref| ref[:file] }.each do |file_path, file_refs|
+            document_id = @document_ids[file_path]
+            next unless document_id
+
+            cross_ref_data << {
+              id: @vertex_id,
+              type: 'edge',
+              label: 'item',
+              outV: ref_result_id,
+              inVs: all_refs,
+              document: document_id,
+              property: 'references'
+            }
+            @vertex_id += 1
+          end
+
+          # Handle document containing the definition
+          def_file = declaration[:file]
+          def_document_id = @document_ids[def_file]
+          if def_document_id && references.none? { |ref| ref[:file] == def_file }
+            cross_ref_data << {
+              id: @vertex_id,
+              type: 'edge',
+              label: 'item',
+              outV: ref_result_id,
+              inVs: all_refs,
+              document: def_document_id,
+              property: 'references'
+            }
+            @vertex_id += 1
+          end
+        end
+
+        cross_ref_data
       end
 
       private
@@ -87,97 +167,145 @@ module Hind
           positionEncoding: 'utf-16',
           toolInfo: {
             name: 'hind',
-            version: VERSION
+            version: Hind::VERSION
           }
         })
 
-        @global_state.project_id = emit_vertex('project', {kind: 'ruby'})
+        @global_state.project_id = emit_vertex('project', { kind: 'ruby' })
       end
 
       def setup_document
-        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
+        return unless @current_uri
+
+        file_path = File.join(@metadata[:projectRoot], @current_uri)
 
         @document_id = emit_vertex('document', {
           uri: path_to_uri(file_path),
           languageId: 'ruby'
         })
-        @document_ids[file_path] = @document_id
+        @document_ids[@current_uri] = @document_id
 
         emit_edge('contains', @global_state.project_id, [@document_id]) if @global_state.project_id
       end
 
       def finalize_document
-        file_path = File.join(@metadata[:projectRoot], @metadata[:uri])
-        ranges = @global_state.ranges[file_path]
+        return unless @current_uri
 
-        return unless ranges&.any?
+        ranges = @global_state.get_ranges_for_file(@current_uri)
+        if ranges&.any?
+          emit_edge('contains', @document_id, ranges)
+        end
+      end
+
+      def create_range(start_location, end_location)
+        return nil unless @current_uri && start_location && end_location
 
-        emit_edge('contains', @document_id, ranges)
+        range_id = emit_vertex('range', {
+          start: {
+            line: start_location.start_line - 1,
+            character: start_location.start_column
+          },
+          end: {
+            line: end_location.end_line - 1,
+            character: end_location.end_column
+          }
+        })
+
+        @global_state.add_range(@current_uri, range_id)
+        range_id
       end
 
-      def update_cross_file_references
-        @global_state.references.each do |qualified_name, references|
-          definition = @global_state.definitions[qualified_name]
-          next unless definition
+      def emit_vertex(label, data = nil)
+        vertex = {
+          id: @vertex_id,
+          type: 'vertex',
+          label: label
+        }
 
-          result_set_id = @global_state.result_sets[qualified_name]
-          next unless result_set_id
+        if data
+          if %w[hoverResult definitionResult referenceResult].include?(label)
+            vertex[:result] = format_hover_data(data)
+          else
+            vertex.merge!(data)
+          end
+        end
 
-          ref_result_id = emit_vertex('referenceResult')
-          emit_edge('textDocument/references', result_set_id, ref_result_id)
+        @lsif_data << vertex
+        @vertex_id += 1
+        @vertex_id - 1
+      end
 
-          # Collect all reference range IDs
-          all_refs = references.map { |ref| ref[:range_id] }
-          all_refs << definition[:range_id]
+      def emit_edge(label, out_v, in_v, property = nil)
+        return unless out_v && valid_in_v?(in_v)
 
-          # Group references by document
-          reference_documents = references.group_by { |ref| ref[:file] }
-          reference_documents.each_key do |file_path|
-            document_id = @document_ids[file_path]
-            next unless document_id
+        edge = {
+          id: @vertex_id,
+          type: 'edge',
+          label: label,
+          outV: out_v
+        }
 
-            emit_edge('item', ref_result_id, all_refs, 'references')
-          end
+        if in_v.is_a?(Array)
+          edge[:inVs] = in_v
+        else
+          edge[:inV] = in_v
+        end
 
-          # Handle definition document if not already included
-          def_document_id = @document_ids[definition[:file]]
-          if def_document_id && references.none? { |ref| ref[:file] == definition[:file] }
-            emit_edge('item', ref_result_id, all_refs, 'references')
-          end
+        edge[:document] = @document_id if label == 'item'
+        edge[:property] = property if property
+
+        @lsif_data << edge
+        @vertex_id += 1
+        @vertex_id - 1
+      end
+
+      def generate_hover_content(declaration)
+        case declaration[:type]
+        when :method
+          sig = []
+          sig << "def #{declaration[:name]}"
+          sig << "(#{declaration[:params]})" if declaration[:params]
+          sig.join
+        when :class
+          hover = ["class #{declaration[:name]}"]
+          hover << " < #{declaration[:superclass]}" if declaration[:superclass]
+          hover.join
+        when :module
+          "module #{declaration[:name]}"
+        when :constant
+          "#{declaration[:name]} = ..."
+        else
+          declaration[:name].to_s
         end
       end
 
+      def format_hover_data(data)
+        return data unless data[:contents]
+
+        data[:contents] = data[:contents].map do |content|
+          content[:value] = strip_code_block(content[:value])
+          content
+        end
+        data
+      end
+
+      def strip_code_block(text)
+        text.gsub(/```.*\n?/, '').strip
+      end
+
       def valid_in_v?(in_v)
         return false unless in_v
         return in_v.any? if in_v.is_a?(Array)
-
         true
       end
 
-      def edge_document(label)
-        (label == 'item') ? @document_id : nil
-      end
-
       def path_to_uri(path)
-        normalized_path = path.tr('\\', '/')
+        return nil unless path
+        normalized_path = path.gsub('\\', '/')
         normalized_path = normalized_path.sub(%r{^file://}, '')
         absolute_path = File.expand_path(normalized_path)
         "file://#{absolute_path}"
       end
-
-      def make_hover_content(text)
-        {
-          contents: [{
-            language: 'ruby',
-            value: strip_code_block(text)
-          }]
-        }
-      end
-
-      def strip_code_block(text)
-        # Strip any existing code block markers and normalize
-        text.gsub(/```.*\n?/, '').strip
-      end
     end
   end
 end

data/lib/hind/lsif/global_state.rb

@@ -1,17 +1,36 @@
+# lib/hind/lsif/global_state.rb
 # frozen_string_literal: true
 
 module Hind
   module LSIF
     class GlobalState
-      attr_reader :result_sets, :definitions, :references, :ranges
       attr_accessor :project_id
+      attr_reader :declarations, :references, :result_sets, :ranges
 
       def initialize
-        @result_sets = {}  # {qualified_name => result_set_id}
-        @definitions = {}  # {qualified_name => {file: file_path, range_id: id}}
-        @references = {}   # {qualified_name => [{file: file_path, range_id: id}]}
-        @ranges = {}       # {file_path => [range_ids]}
-        @project_id = nil  # Store project ID for reuse across files
+        @declarations = {}    # {qualified_name => {type:, node:, scope:, file:, range_id:, result_set_id:}}
+        @references = {}      # {qualified_name => [{file:, range_id:, type:}, ...]}
+        @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)
+        @declarations[qualified_name] = data
+        @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)
+        @references[qualified_name] ||= []
+        @references[qualified_name] << {
+          file: file_path,
+          range_id: range_id,
+          type: type
+        }
       end
 
       def add_range(file_path, range_id)
@@ -19,13 +38,133 @@ module Hind
         @ranges[file_path] << range_id
       end
 
-      def add_definition(qualified_name, file_path, range_id)
-        @definitions[qualified_name] = {file: file_path, range_id: range_id}
+      def has_declaration?(qualified_name)
+        @declarations.key?(qualified_name)
       end
 
-      def add_reference(qualified_name, file_path, range_id)
-        @references[qualified_name] ||= []
-        @references[qualified_name] << {file: file_path, range_id: range_id}
+      def get_declaration(qualified_name)
+        @declarations[qualified_name]
+      end
+
+      def get_references(qualified_name)
+        @references[qualified_name] || []
+      end
+
+      def get_result_set(qualified_name)
+        @result_sets[qualified_name]
+      end
+
+      def get_ranges_for_file(file_path)
+        @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}"
+            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
+        }
+      end
+
+      private
+
+      def declaration_types_count
+        @declarations.values.each_with_object(Hash.new(0)) do |decl, counts|
+          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