Strip out hover support

AJenbo · AJenbo · commit f72553358c19 · 2026-02-13T00:05:48.000+01:00
diff --git a/example.php b/example.php
@@ -1,13 +1,48 @@
 <?php
 
+/**
+ * PHPantomLSP Demo File
+ *
+ * This file demonstrates the hover functionality of PHPantomLSP.
+ * Try hovering over the word "PHPantom" below to see the special message!
+ */
+
 namespace Demo;
 
 class PHPantomDemo
 {
-    public int $count = 0;
+    /**
+     * Welcome to PHPantom - the phantom PHP Language Server!
+     *
+     * Hover over "PHPantom" anywhere in this file to see the LSP in action.
+     */
+    public function demonstrateHover(): void
+    {
+        // PHPantom provides basic LSP functionality
+        $message = "PHPantom is a minimal LSP server written in Rust";
+
+        echo $message . PHP_EOL;
+    }
 
-    public function regularCode(string $text): string
+    /**
+     * Regular PHP code - hovering over these words won't trigger special behavior
+     */
+    public function regularCode(): string
     {
+        $variable = "This is regular code";
+        $function = "Some function";
+
+        // Only "PHPantom" triggers the hover message
+        return "PHPantom rocks!";
     }
 }
 
+// Create an instance and run the demo
+$demo = new PHPantomDemo();
+$demo->demonstrateHover();
+
+// More PHPantom references for testing
+// Try hovering over PHPantom in comments too!
+$phantom = "PHPantom";
+
+?>
diff --git a/src/lib.rs b/src/lib.rs
@@ -116,42 +116,6 @@ impl Backend {
         }
     }
 
-    fn get_word_at_position(&self, content: &str, position: Position) -> Option<String> {
-        let lines: Vec<&str> = content.lines().collect();
-        if position.line as usize >= lines.len() {
-            return None;
-        }
-
-        let line = lines[position.line as usize];
-        let chars: Vec<char> = line.chars().collect();
-
-        if position.character as usize > chars.len() {
-            return None;
-        }
-
-        let pos = position.character as usize;
-
-        // Find word boundaries
-        let mut start = pos;
-        let mut end = pos;
-
-        // Move start backward to word boundary
-        while start > 0 && chars[start - 1].is_alphanumeric() {
-            start -= 1;
-        }
-
-        // Move end forward to word boundary
-        while end < chars.len() && chars[end].is_alphanumeric() {
-            end += 1;
-        }
-
-        if start < end {
-            Some(chars[start..end].iter().collect())
-        } else {
-            None
-        }
-    }
-
     /// Extract a string representation of a type hint from the AST.
     fn extract_hint_string(hint: &Hint) -> String {
         match hint {
@@ -453,7 +417,6 @@ impl LanguageServer for Backend {
     async fn initialize(&self, _: InitializeParams) -> Result<InitializeResult> {
         Ok(InitializeResult {
             capabilities: ServerCapabilities {
-                hover_provider: Some(HoverProviderCapability::Simple(true)),
                 completion_provider: Some(CompletionOptions {
                     resolve_provider: Some(false),
                     trigger_characters: Some(vec![
@@ -535,35 +498,6 @@ impl LanguageServer for Backend {
             .await;
     }
 
-    async fn hover(&self, params: HoverParams) -> Result<Option<Hover>> {
-        let uri = params
-            .text_document_position_params
-            .text_document
-            .uri
-            .to_string();
-        let position = params.text_document_position_params.position;
-
-        let content = if let Ok(files) = self.open_files.lock() {
-            files.get(&uri).cloned()
-        } else {
-            None
-        };
-
-        if let Some(content) = content
-            && let Some(word) = self.get_word_at_position(&content, position)
-            && word == "PHPantom"
-        {
-            return Ok(Some(Hover {
-                contents: HoverContents::Scalar(MarkedString::String(
-                    "Welcome to PHPantomLSP!".to_string(),
-                )),
-                range: None,
-            }));
-        }
-
-        Ok(None)
-    }
-
     async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
         let uri = params.text_document_position.text_document.uri.to_string();
         let position = params.text_document_position.position;
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs
@@ -24,10 +24,6 @@ async fn test_initialize_capabilities() {
     let result = backend.initialize(params).await.unwrap();
 
     let caps = result.capabilities;
-    assert!(
-        caps.hover_provider.is_some(),
-        "Hover provider should be enabled"
-    );
     assert!(
         caps.completion_provider.is_some(),
         "Completion provider should be enabled"
@@ -39,7 +35,7 @@ async fn test_did_open_stores_file() {
     let backend = create_test_backend();
 
     let uri = Url::parse("file:///test.php").unwrap();
-    let text = "<?php\necho 'hello';\n".to_string();
+    let text = "<?php\nclass Stored { function m() {} }\n".to_string();
 
     let params = DidOpenTextDocumentParams {
         text_document: TextDocumentItem {
@@ -52,99 +48,13 @@ async fn test_did_open_stores_file() {
 
     backend.did_open(params).await;
 
-    // Verify by requesting a hover (which accesses stored content)
-    let hover_params = HoverParams {
-        text_document_position_params: TextDocumentPositionParams {
-            text_document: TextDocumentIdentifier { uri },
-            position: Position {
-                line: 0,
-                character: 0,
-            },
-        },
-        work_done_progress_params: WorkDoneProgressParams::default(),
-    };
-
-    let result = backend.hover(hover_params).await;
-    assert!(result.is_ok());
-}
-
-#[tokio::test]
-async fn test_hover_on_phpantom() {
-    let backend = create_test_backend();
-
-    let uri = Url::parse("file:///test.php").unwrap();
-    let text = "<?php\nPHPantom\n".to_string();
-
-    let open_params = DidOpenTextDocumentParams {
-        text_document: TextDocumentItem {
-            uri: uri.clone(),
-            language_id: "php".to_string(),
-            version: 1,
-            text,
-        },
-    };
-    backend.did_open(open_params).await;
-
-    let hover_params = HoverParams {
-        text_document_position_params: TextDocumentPositionParams {
-            text_document: TextDocumentIdentifier { uri },
-            position: Position {
-                line: 1,
-                character: 3,
-            },
-        },
-        work_done_progress_params: WorkDoneProgressParams::default(),
-    };
-
-    let result = backend.hover(hover_params).await.unwrap();
-    assert!(
-        result.is_some(),
-        "Hover should return a result for PHPantom"
-    );
-
-    if let Some(hover) = result {
-        match hover.contents {
-            HoverContents::Scalar(MarkedString::String(s)) => {
-                assert_eq!(s, "Welcome to PHPantomLSP!");
-            }
-            _ => panic!("Unexpected hover content type"),
-        }
-    }
-}
-
-#[tokio::test]
-async fn test_hover_on_other_word_returns_none() {
-    let backend = create_test_backend();
-
-    let uri = Url::parse("file:///test.php").unwrap();
-    let text = "<?php\nhelloworld\n".to_string();
-
-    let open_params = DidOpenTextDocumentParams {
-        text_document: TextDocumentItem {
-            uri: uri.clone(),
-            language_id: "php".to_string(),
-            version: 1,
-            text,
-        },
-    };
-    backend.did_open(open_params).await;
-
-    let hover_params = HoverParams {
-        text_document_position_params: TextDocumentPositionParams {
-            text_document: TextDocumentIdentifier { uri },
-            position: Position {
-                line: 1,
-                character: 3,
-            },
-        },
-        work_done_progress_params: WorkDoneProgressParams::default(),
-    };
-
-    let result = backend.hover(hover_params).await.unwrap();
+    // Verify the file was stored by checking the AST map has an entry
+    let classes = backend.get_classes_for_uri(&uri.to_string());
     assert!(
-        result.is_none(),
-        "Hover should return None for non-PHPantom words"
+        classes.is_some(),
+        "AST map should have an entry after did_open"
     );
+    assert_eq!(classes.unwrap().len(), 1);
 }
 
 #[tokio::test]
@@ -201,7 +111,7 @@ async fn test_did_change_updates_content() {
     let backend = create_test_backend();
 
     let uri = Url::parse("file:///test.php").unwrap();
-    let initial_text = "<?php\nPHPantom\n".to_string();
+    let initial_text = "<?php\nclass A { function first() {} }\n".to_string();
 
     let open_params = DidOpenTextDocumentParams {
         text_document: TextDocumentItem {
@@ -213,7 +123,10 @@ async fn test_did_change_updates_content() {
     };
     backend.did_open(open_params).await;
 
-    // Change the content to something else
+    let classes = backend.get_classes_for_uri(&uri.to_string()).unwrap();
+    assert_eq!(classes[0].methods.len(), 1);
+
+    // Change the content to add a second method
     let change_params = DidChangeTextDocumentParams {
         text_document: VersionedTextDocumentIdentifier {
             uri: uri.clone(),
@@ -222,27 +135,17 @@ async fn test_did_change_updates_content() {
         content_changes: vec![TextDocumentContentChangeEvent {
             range: None,
             range_length: None,
-            text: "<?php\nhelloworld\n".to_string(),
+            text: "<?php\nclass A { function first() {} function second() {} }\n".to_string(),
         }],
     };
     backend.did_change(change_params).await;
 
-    // Hover should now return None since "PHPantom" is gone
-    let hover_params = HoverParams {
-        text_document_position_params: TextDocumentPositionParams {
-            text_document: TextDocumentIdentifier { uri },
-            position: Position {
-                line: 1,
-                character: 3,
-            },
-        },
-        work_done_progress_params: WorkDoneProgressParams::default(),
-    };
-
-    let result = backend.hover(hover_params).await.unwrap();
-    assert!(
-        result.is_none(),
-        "After change, hover should not find PHPantom"
+    // Verify content was updated by checking the re-parsed AST
+    let classes = backend.get_classes_for_uri(&uri.to_string()).unwrap();
+    assert_eq!(
+        classes[0].methods.len(),
+        2,
+        "After change, class should have 2 methods"
     );
 }
 
@@ -251,7 +154,7 @@ async fn test_did_close_removes_file() {
     let backend = create_test_backend();
 
     let uri = Url::parse("file:///test.php").unwrap();
-    let text = "<?php\nPHPantom\n".to_string();
+    let text = "<?php\nclass Z { function z() {} }\n".to_string();
 
     let open_params = DidOpenTextDocumentParams {
         text_document: TextDocumentItem {
@@ -263,26 +166,19 @@ async fn test_did_close_removes_file() {
     };
     backend.did_open(open_params).await;
 
+    assert!(backend.get_classes_for_uri(&uri.to_string()).is_some());
+
     // Close the file
     let close_params = DidCloseTextDocumentParams {
         text_document: TextDocumentIdentifier { uri: uri.clone() },
     };
     backend.did_close(close_params).await;
 
-    // Hover should return None since the file is closed
-    let hover_params = HoverParams {
-        text_document_position_params: TextDocumentPositionParams {
-            text_document: TextDocumentIdentifier { uri },
-            position: Position {
-                line: 1,
-                character: 3,
-            },
-        },
-        work_done_progress_params: WorkDoneProgressParams::default(),
-    };
-
-    let result = backend.hover(hover_params).await.unwrap();
-    assert!(result.is_none(), "After close, hover should return None");
+    // AST map entry should be removed after close
+    assert!(
+        backend.get_classes_for_uri(&uri.to_string()).is_none(),
+        "After close, AST map should not have an entry"
+    );
 }
 
 // ─── AST Parsing Tests ─────────────────────────────────────────────────────
