collie-lsp 0.1.0

data/lib/collie_lsp/handlers/rename.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Rename symbol support
+    module Rename
+      module_function
+
+      # Handle textDocument/rename request
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param _collie [CollieWrapper] Collie wrapper (unused)
+      # @param writer [Object] Response writer
+      def handle(request, document_store, _collie, writer)
+        uri = request[:params][:textDocument][:uri]
+        position = request[:params][:position]
+        new_name = request[:params][:newName]
+        doc = document_store.get(uri)
+
+        unless doc
+          writer.write(id: request[:id], result: nil)
+          return
+        end
+
+        ast = doc[:ast]
+        unless ast
+          writer.write(id: request[:id], result: nil)
+          return
+        end
+
+        # Find symbol at position
+        symbol = find_symbol_at_position(doc[:text], position)
+        unless symbol
+          writer.write(id: request[:id], result: nil)
+          return
+        end
+
+        # Validate new name
+        unless valid_name?(symbol, new_name, ast)
+          writer.write(id: request[:id], result: nil)
+          return
+        end
+
+        # Build workspace edit with all occurrences
+        workspace_edit = build_workspace_edit(uri, symbol, new_name, doc[:text], ast)
+
+        writer.write(
+          id: request[:id],
+          result: workspace_edit
+        )
+      end
+
+      # Find symbol at the given position
+      # @param text [String] Document text
+      # @param position [Hash] LSP position
+      # @return [String, nil] Symbol name or nil
+      def find_symbol_at_position(text, position)
+        lines = text.lines
+        line = lines[position[:line]]
+        return nil unless line
+
+        # Extract word at character position
+        char = position[:character]
+        start_pos = char
+        end_pos = char
+
+        # Move backwards to find word start
+        start_pos -= 1 while start_pos.positive? && line[start_pos - 1] =~ /[A-Za-z0-9_]/
+        # Move forwards to find word end
+        end_pos += 1 while end_pos < line.length && line[end_pos] =~ /[A-Za-z0-9_]/
+
+        line[start_pos...end_pos]
+      end
+
+      # Validate the new name based on symbol type
+      # @param old_name [String] Old symbol name
+      # @param new_name [String] New symbol name
+      # @param ast [Hash] Parsed AST
+      # @return [Boolean] True if valid
+      def valid_name?(old_name, new_name, ast)
+        return false if new_name.empty?
+
+        # Check if old symbol is a token (should be UPPER_CASE)
+        is_token = ast[:declarations]&.any? do |decl|
+          decl[:kind] == :token && decl[:names]&.include?(old_name)
+        end
+
+        pattern = if is_token
+                    # Token names should be uppercase
+                    /^[A-Z][A-Z0-9_]*$/
+                  else
+                    # Nonterminal names should be lowercase
+                    /^[a-z][a-z0-9_]*$/
+                  end
+
+        !!(new_name =~ pattern)
+      end
+
+      # Build workspace edit with all rename changes
+      # @param uri [String] Document URI
+      # @param old_name [String] Old symbol name
+      # @param new_name [String] New symbol name
+      # @param text [String] Document text
+      # @param ast [Hash] Parsed AST
+      # @return [Hash] LSP workspace edit
+      def build_workspace_edit(uri, old_name, new_name, text, ast)
+        # Find all occurrences of the symbol
+        locations = find_all_occurrences(text, old_name, ast)
+
+        edits = locations.map do |loc|
+          {
+            range: {
+              start: {
+                line: loc[:line] - 1,
+                character: loc[:column] - 1
+              },
+              end: {
+                line: loc[:line] - 1,
+                character: loc[:column] + old_name.length - 1
+              }
+            },
+            newText: new_name
+          }
+        end
+
+        {
+          changes: {
+            uri => edits
+          }
+        }
+      end
+
+      # Find all occurrences of a symbol in the document
+      # @param text [String] Document text
+      # @param symbol [String] Symbol to find
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] Array of locations
+      def find_all_occurrences(text, symbol, ast)
+        locations = []
+
+        # Find declaration
+        decl_loc = find_declaration_location(ast, symbol)
+        locations << decl_loc if decl_loc
+
+        # Find all usages in rules
+        locations.concat(find_usage_locations(text, symbol, ast))
+
+        locations.uniq { |loc| [loc[:line], loc[:column]] }
+      end
+
+      # Find declaration location
+      # @param ast [Hash] Parsed AST
+      # @param symbol [String] Symbol name
+      # @return [Hash, nil] Location or nil
+      def find_declaration_location(ast, symbol)
+        # Check token declarations
+        ast[:declarations]&.each do |decl|
+          next unless decl[:kind] == :token
+
+          return decl[:location] if decl[:names]&.include?(symbol) && decl[:location]
+        end
+
+        # Check nonterminal rules
+        rule = ast[:rules]&.find { |r| r[:name] == symbol }
+        return rule[:location] if rule&.dig(:location)
+
+        nil
+      end
+
+      # Find all usage locations in rules
+      # @param text [String] Document text
+      # @param symbol [String] Symbol to find
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] Array of locations
+      def find_usage_locations(text, symbol, ast)
+        locations = []
+        lines = text.lines
+
+        ast[:rules]&.each do |rule|
+          next unless rule[:location]
+
+          # Search from rule location onwards
+          start_line = rule[:location][:line] - 1
+          search_end = find_rule_end(lines, start_line)
+
+          (start_line..search_end).each do |line_idx|
+            line = lines[line_idx]
+            next unless line
+
+            # Find all occurrences in this line
+            col = 0
+            while (pos = line.index(symbol, col))
+              # Verify it's a whole word (not part of another identifier)
+              before_char = pos.positive? ? line[pos - 1] : ' '
+              after_char = line[pos + symbol.length] || ' '
+
+              if before_char !~ /[A-Za-z0-9_]/ && after_char !~ /[A-Za-z0-9_]/
+                locations << {
+                  line: line_idx + 1,
+                  column: pos + 1
+                }
+              end
+
+              col = pos + 1
+            end
+          end
+        end
+
+        locations
+      end
+
+      # Find the end line of a rule
+      # @param lines [Array<String>] Document lines
+      # @param start_line [Integer] Rule start line
+      # @return [Integer] End line index
+      def find_rule_end(lines, start_line)
+        # Look for the semicolon that ends the rule
+        (start_line...lines.length).each do |idx|
+          return idx if lines[idx]&.include?(';')
+        end
+
+        lines.length - 1
+      end
+    end
+  end
+end

data/lib/collie_lsp/handlers/semantic_tokens.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Semantic tokens support for syntax highlighting
+    module SemanticTokens
+      module_function
+
+      # LSP semantic token types
+      TOKEN_TYPES = %w[
+        namespace
+        type
+        class
+        enum
+        interface
+        struct
+        typeParameter
+        parameter
+        variable
+        property
+        enumMember
+        event
+        function
+        method
+        macro
+        keyword
+        modifier
+        comment
+        string
+        number
+        regexp
+        operator
+      ].freeze
+
+      # LSP semantic token modifiers
+      TOKEN_MODIFIERS = %w[
+        declaration
+        definition
+        readonly
+        static
+        deprecated
+        abstract
+        async
+        modification
+        documentation
+        defaultLibrary
+      ].freeze
+
+      # Handle textDocument/semanticTokens/full request
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param _collie [CollieWrapper] Collie wrapper (unused)
+      # @param writer [Object] Response writer
+      def handle(request, document_store, _collie, writer)
+        uri = request[:params][:textDocument][:uri]
+        doc = document_store.get(uri)
+
+        unless doc
+          writer.write(id: request[:id], result: { data: [] })
+          return
+        end
+
+        ast = doc[:ast]
+        unless ast
+          writer.write(id: request[:id], result: { data: [] })
+          return
+        end
+
+        # Build semantic tokens
+        tokens = build_semantic_tokens(doc[:text], ast)
+
+        writer.write(
+          id: request[:id],
+          result: { data: tokens }
+        )
+      end
+
+      # Build semantic tokens array
+      # @param text [String] Document text
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Integer>] Encoded semantic tokens
+      def build_semantic_tokens(text, ast)
+        tokens = []
+        symbol_info = build_symbol_info(ast)
+
+        lines = text.lines
+        lines.each_with_index do |line, line_idx|
+          tokens.concat(tokenize_line(line, line_idx, symbol_info))
+        end
+
+        # Convert to LSP format (delta encoding)
+        encode_tokens(tokens)
+      end
+
+      # Build symbol information from AST
+      # @param ast [Hash] Parsed AST
+      # @return [Hash] Symbol information
+      def build_symbol_info(ast)
+        info = { tokens: {}, nonterminals: {}, keywords: {} }
+
+        # Collect token declarations
+        ast[:declarations]&.each do |decl|
+          next unless decl[:kind] == :token
+
+          decl[:names]&.each do |name|
+            info[:tokens][name] = true
+          end
+        end
+
+        # Collect nonterminal rules
+        ast[:rules]&.each do |rule|
+          info[:nonterminals][rule[:name]] = true
+        end
+
+        # Grammar keywords
+        %w[%token %type %left %right %nonassoc %prec %union %start].each do |kw|
+          info[:keywords][kw] = true
+        end
+
+        info
+      end
+
+      # Tokenize a single line
+      # @param line [String] Line text
+      # @param line_idx [Integer] Line index
+      # @param symbol_info [Hash] Symbol information
+      # @return [Array<Hash>] Tokens in this line
+      def tokenize_line(line, line_idx, symbol_info)
+        tokens = []
+        pos = 0
+
+        while pos < line.length
+          # Skip whitespace
+          if line[pos] =~ /\s/
+            pos += 1
+            next
+          end
+
+          # Check for keywords
+          if line[pos] == '%'
+            keyword = extract_keyword(line, pos)
+            if keyword && symbol_info[:keywords][keyword]
+              tokens << create_token(line_idx, pos, keyword.length, :keyword)
+              pos += keyword.length
+              next
+            end
+          end
+
+          # Check for comments
+          if line[pos..(pos + 1)] == '//'
+            # Rest of line is a comment
+            tokens << create_token(line_idx, pos, line.length - pos, :comment)
+            break
+          end
+
+          if line[pos..(pos + 1)] == '/*'
+            # Block comment (simplified - doesn't handle multi-line)
+            end_pos = line.index('*/', pos + 2)
+            if end_pos
+              tokens << create_token(line_idx, pos, end_pos + 2 - pos, :comment)
+              pos = end_pos + 2
+              next
+            end
+          end
+
+          # Check for strings
+          if ['"', "'"].include?(line[pos])
+            str_len = extract_string_length(line, pos)
+            if str_len
+              tokens << create_token(line_idx, pos, str_len, :string)
+              pos += str_len
+              next
+            end
+          end
+
+          # Check for identifiers
+          if line[pos] =~ /[A-Za-z_]/
+            identifier = extract_identifier(line, pos)
+            if identifier
+              type = classify_identifier(identifier, symbol_info)
+              tokens << create_token(line_idx, pos, identifier.length, type)
+              pos += identifier.length
+              next
+            end
+          end
+
+          # Check for operators
+          if line[pos] =~ /[{}:;|]/
+            tokens << create_token(line_idx, pos, 1, :operator)
+            pos += 1
+            next
+          end
+
+          # Skip unrecognized characters
+          pos += 1
+        end
+
+        tokens
+      end
+
+      # Extract keyword from position
+      # @param line [String] Line text
+      # @param pos [Integer] Starting position
+      # @return [String, nil] Keyword or nil
+      def extract_keyword(line, pos)
+        return nil unless line[pos] == '%'
+
+        match = line[pos..].match(/^%[a-z]+/)
+        match&.to_s
+      end
+
+      # Extract string length
+      # @param line [String] Line text
+      # @param pos [Integer] Starting position
+      # @return [Integer, nil] String length or nil
+      def extract_string_length(line, pos)
+        quote = line[pos]
+        end_pos = pos + 1
+
+        while end_pos < line.length
+          return end_pos - pos + 1 if line[end_pos] == quote && line[end_pos - 1] != '\\'
+
+          end_pos += 1
+        end
+
+        nil
+      end
+
+      # Extract identifier
+      # @param line [String] Line text
+      # @param pos [Integer] Starting position
+      # @return [String, nil] Identifier or nil
+      def extract_identifier(line, pos)
+        match = line[pos..].match(/^[A-Za-z_][A-Za-z0-9_]*/)
+        match&.to_s
+      end
+
+      # Classify identifier type
+      # @param identifier [String] Identifier name
+      # @param symbol_info [Hash] Symbol information
+      # @return [Symbol] Token type
+      def classify_identifier(identifier, symbol_info)
+        return :enumMember if symbol_info[:tokens][identifier]
+        return :function if symbol_info[:nonterminals][identifier]
+
+        :variable
+      end
+
+      # Create a token
+      # @param line [Integer] Line number
+      # @param col [Integer] Column number
+      # @param length [Integer] Token length
+      # @param type [Symbol] Token type
+      # @return [Hash] Token hash
+      def create_token(line, col, length, type)
+        {
+          line: line,
+          startChar: col,
+          length: length,
+          tokenType: token_type_index(type),
+          tokenModifiers: 0
+        }
+      end
+
+      # Get token type index
+      # @param type [Symbol] Token type symbol
+      # @return [Integer] Token type index
+      def token_type_index(type)
+        type_str = type.to_s
+        index = TOKEN_TYPES.index(type_str)
+        index || TOKEN_TYPES.index('variable')
+      end
+
+      # Encode tokens in LSP delta format
+      # @param tokens [Array<Hash>] Tokens
+      # @return [Array<Integer>] Encoded tokens
+      def encode_tokens(tokens)
+        encoded = []
+        prev_line = 0
+        prev_char = 0
+
+        tokens.sort_by { |t| [t[:line], t[:startChar]] }.each do |token|
+          delta_line = token[:line] - prev_line
+          delta_char = delta_line.zero? ? token[:startChar] - prev_char : token[:startChar]
+
+          encoded.push(
+            delta_line,
+            delta_char,
+            token[:length],
+            token[:tokenType],
+            token[:tokenModifiers]
+          )
+
+          prev_line = token[:line]
+          prev_char = token[:startChar]
+        end
+
+        encoded
+      end
+    end
+  end
+end

data/lib/collie_lsp/handlers/workspace_symbol.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module CollieLsp
+  module Handlers
+    # Workspace-wide symbol search
+    module WorkspaceSymbol
+      module_function
+
+      # Handle workspace/symbol request
+      # @param request [Hash] LSP request
+      # @param document_store [DocumentStore] Document store
+      # @param _collie [CollieWrapper] Collie wrapper (unused)
+      # @param writer [Object] Response writer
+      def handle(request, document_store, _collie, writer)
+        query = request[:params][:query] || ''
+        symbols = search_symbols(query, document_store)
+
+        writer.write(
+          id: request[:id],
+          result: symbols
+        )
+      end
+
+      # Search for symbols across all open documents
+      # @param query [String] Search query
+      # @param document_store [DocumentStore] Document store
+      # @return [Array<Hash>] Matching symbols
+      def search_symbols(query, document_store)
+        symbols = []
+
+        # Search in all open documents
+        document_store.instance_variable_get(:@documents).each do |uri, doc|
+          next unless doc[:ast]
+
+          symbols.concat(search_in_document(query, uri, doc[:ast]))
+        end
+
+        # Sort by relevance (exact matches first, then contains)
+        symbols.sort_by { |s| symbol_relevance(s[:name], query) }
+      end
+
+      # Search for symbols in a single document
+      # @param query [String] Search query
+      # @param uri [String] Document URI
+      # @param ast [Hash] Parsed AST
+      # @return [Array<Hash>] Matching symbols
+      def search_in_document(query, uri, ast)
+        symbols = []
+
+        # Search token declarations
+        ast[:declarations]&.each do |decl|
+          next unless decl[:kind] == :token && decl[:location]
+
+          decl[:names]&.each do |name|
+            next unless matches_query?(name, query)
+
+            symbols << create_symbol_info(
+              name: name,
+              kind: 14, # Constant
+              uri: uri,
+              location: decl[:location],
+              container_name: 'Tokens'
+            )
+          end
+
+          # Search type declarations
+          next unless decl[:kind] == :type && decl[:location]
+
+          decl[:names]&.each do |name|
+            next unless matches_query?(name, query)
+
+            symbols << create_symbol_info(
+              name: name,
+              kind: 7, # Class
+              uri: uri,
+              location: decl[:location],
+              container_name: 'Types'
+            )
+          end
+        end
+
+        # Search nonterminal rules
+        ast[:rules]&.each do |rule|
+          next unless rule[:location] && matches_query?(rule[:name], query)
+
+          symbols << create_symbol_info(
+            name: rule[:name],
+            kind: 12, # Function
+            uri: uri,
+            location: rule[:location],
+            container_name: 'Rules'
+          )
+        end
+
+        symbols
+      end
+
+      # Check if a symbol name matches the query
+      # @param name [String] Symbol name
+      # @param query [String] Search query
+      # @return [Boolean] True if matches
+      def matches_query?(name, query)
+        return true if query.empty?
+
+        # Case-insensitive substring match
+        name.downcase.include?(query.downcase)
+      end
+
+      # Calculate symbol relevance score
+      # @param name [String] Symbol name
+      # @param query [String] Search query
+      # @return [Integer] Relevance score (lower is better)
+      def symbol_relevance(name, query)
+        return 0 if query.empty?
+
+        name_lower = name.downcase
+        query_lower = query.downcase
+
+        # Exact match
+        return 1 if name_lower == query_lower
+
+        # Starts with query
+        return 2 if name_lower.start_with?(query_lower)
+
+        # Contains query
+        return 3 if name_lower.include?(query_lower)
+
+        # No match
+        4
+      end
+
+      # Create a symbol information object
+      # @param name [String] Symbol name
+      # @param kind [Integer] LSP symbol kind
+      # @param uri [String] Document URI
+      # @param location [Hash] Symbol location
+      # @param container_name [String] Container name
+      # @return [Hash] LSP symbol information
+      def create_symbol_info(name:, kind:, uri:, location:, container_name: nil)
+        line = location[:line] - 1
+        column = location[:column] - 1
+
+        info = {
+          name: name,
+          kind: kind,
+          location: {
+            uri: uri,
+            range: {
+              start: { line: line, character: column },
+              end: { line: line, character: column + name.length }
+            }
+          }
+        }
+
+        info[:containerName] = container_name if container_name
+
+        info
+      end
+    end
+  end
+end