Add properties and method signatures

Author: AJenbo

example.php

@@ -1,48 +1,13 @@
 <?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
 {
-    /**
-     * 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 int $count = 0;
 
-    /**
-     * Regular PHP code - hovering over these words won't trigger special behavior
-     */
-    public function regularCode(): string
+    public function regularCode(string $text): 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";
-
-?>

src/lib.rs

@@ -8,14 +8,56 @@ use bumpalo::Bump;
 use mago_syntax::ast::*;
 use mago_syntax::parser::parse_file_content;
 
+/// Stores extracted parameter information from a parsed PHP method.
+#[derive(Debug, Clone)]
+pub struct ParameterInfo {
+    /// The parameter name including the `$` prefix (e.g. "$text").
+    pub name: String,
+    /// Whether this parameter is required (no default value and not variadic).
+    pub is_required: bool,
+    /// Optional type hint string (e.g. "string", "int", "?Foo").
+    pub type_hint: Option<String>,
+    /// Whether this parameter is variadic (has `...`).
+    pub is_variadic: bool,
+    /// Whether this parameter is passed by reference (has `&`).
+    pub is_reference: bool,
+}
+
+/// Stores extracted method information from a parsed PHP class.
+#[derive(Debug, Clone)]
+pub struct MethodInfo {
+    /// The method name (e.g. "updateText").
+    pub name: String,
+    /// The parameters of the method.
+    pub parameters: Vec<ParameterInfo>,
+    /// Optional return type hint string (e.g. "void", "string", "?int").
+    pub return_type: Option<String>,
+    /// Whether the method is static.
+    pub is_static: bool,
+}
+
+/// Stores extracted property information from a parsed PHP class.
+#[derive(Debug, Clone)]
+pub struct PropertyInfo {
+    /// The property name WITHOUT the `$` prefix (e.g. "name", "age").
+    /// This matches PHP access syntax: `$this->name` not `$this->$name`.
+    pub name: String,
+    /// Optional type hint string (e.g. "string", "int").
+    pub type_hint: Option<String>,
+    /// Whether the property is static.
+    pub is_static: bool,
+}
+
 /// Stores extracted class information from a parsed PHP file.
 /// All data is owned so we don't depend on the parser's arena lifetime.
 #[derive(Debug, Clone)]
 pub struct ClassInfo {
     /// The name of the class (e.g. "User").
     pub name: String,
-    /// The names of methods defined directly in this class.
-    pub methods: Vec<String>,
+    /// The methods defined directly in this class.
+    pub methods: Vec<MethodInfo>,
+    /// The properties defined directly in this class.
+    pub properties: Vec<PropertyInfo>,
     /// Byte offset where the class body starts (left brace).
     pub start_offset: u32,
     /// Byte offset where the class body ends (right brace).
@@ -88,6 +130,99 @@ impl Backend {
         }
     }
 
+    /// Extract a string representation of a type hint from the AST.
+    fn extract_hint_string(hint: &Hint) -> String {
+        match hint {
+            Hint::Identifier(ident) => ident.value().to_string(),
+            Hint::Nullable(nullable) => {
+                format!("?{}", Self::extract_hint_string(nullable.hint))
+            }
+            Hint::Union(union) => {
+                let left = Self::extract_hint_string(union.left);
+                let right = Self::extract_hint_string(union.right);
+                format!("{}|{}", left, right)
+            }
+            Hint::Intersection(intersection) => {
+                let left = Self::extract_hint_string(intersection.left);
+                let right = Self::extract_hint_string(intersection.right);
+                format!("{}&{}", left, right)
+            }
+            Hint::Void(ident)
+            | Hint::Never(ident)
+            | Hint::Float(ident)
+            | Hint::Bool(ident)
+            | Hint::Integer(ident)
+            | Hint::String(ident)
+            | Hint::Object(ident)
+            | Hint::Mixed(ident)
+            | Hint::Iterable(ident) => ident.value.to_string(),
+            Hint::Null(keyword)
+            | Hint::True(keyword)
+            | Hint::False(keyword)
+            | Hint::Array(keyword)
+            | Hint::Callable(keyword)
+            | Hint::Static(keyword)
+            | Hint::Self_(keyword)
+            | Hint::Parent(keyword) => keyword.value.to_string(),
+            Hint::Parenthesized(paren) => {
+                format!("({})", Self::extract_hint_string(paren.hint))
+            }
+        }
+    }
+
+    /// Extract parameter information from a method's parameter list.
+    fn extract_parameters(parameter_list: &FunctionLikeParameterList) -> Vec<ParameterInfo> {
+        parameter_list
+            .parameters
+            .iter()
+            .map(|param| {
+                let name = param.variable.name.to_string();
+                let is_variadic = param.ellipsis.is_some();
+                let is_reference = param.ampersand.is_some();
+                let has_default = param.default_value.is_some();
+                let is_required = !has_default && !is_variadic;
+
+                let type_hint = param.hint.as_ref().map(|h| Self::extract_hint_string(h));
+
+                ParameterInfo {
+                    name,
+                    is_required,
+                    type_hint,
+                    is_variadic,
+                    is_reference,
+                }
+            })
+            .collect()
+    }
+
+    /// Extract property information from a class member Property node.
+    fn extract_property_info(property: &Property) -> Vec<PropertyInfo> {
+        let is_static = property.modifiers().iter().any(|m| m.is_static());
+
+        let type_hint = property.hint().map(|h| Self::extract_hint_string(h));
+
+        property
+            .variables()
+            .iter()
+            .map(|var| {
+                let raw_name = var.name.to_string();
+                // Strip the leading `$` for property names since PHP access
+                // syntax is `$this->name` not `$this->$name`.
+                let name = if let Some(stripped) = raw_name.strip_prefix('$') {
+                    stripped.to_string()
+                } else {
+                    raw_name
+                };
+
+                PropertyInfo {
+                    name,
+                    type_hint: type_hint.clone(),
+                    is_static,
+                }
+            })
+            .collect()
+    }
+
     /// Parse PHP source text and extract class information.
     /// Returns a Vec of ClassInfo for all classes found in the file.
     pub fn parse_php(&self, content: &str) -> Vec<ClassInfo> {
@@ -113,9 +248,31 @@ impl Backend {
                     let class_name = class.name.value.to_string();
 
                     let mut methods = Vec::new();
+                    let mut properties = Vec::new();
+
                     for member in class.members.iter() {
-                        if let ClassLikeMember::Method(method) = member {
-                            methods.push(method.name.value.to_string());
+                        match member {
+                            ClassLikeMember::Method(method) => {
+                                let name = method.name.value.to_string();
+                                let parameters = Self::extract_parameters(&method.parameter_list);
+                                let return_type = method
+                                    .return_type_hint
+                                    .as_ref()
+                                    .map(|rth| Self::extract_hint_string(&rth.hint));
+                                let is_static = method.modifiers.iter().any(|m| m.is_static());
+
+                                methods.push(MethodInfo {
+                                    name,
+                                    parameters,
+                                    return_type,
+                                    is_static,
+                                });
+                            }
+                            ClassLikeMember::Property(property) => {
+                                let mut prop_infos = Self::extract_property_info(property);
+                                properties.append(&mut prop_infos);
+                            }
+                            _ => {}
                         }
                     }
 
@@ -125,6 +282,7 @@ impl Backend {
                     classes.push(ClassInfo {
                         name: class_name,
                         methods,
+                        properties,
                         start_offset,
                         end_offset,
                     });
@@ -175,6 +333,43 @@ impl Backend {
             .find(|c| offset >= c.start_offset && offset <= c.end_offset)
     }
 
+    /// Build the label showing the full method signature.
+    ///
+    /// Example: `regularCode(string $text, $frogs = false): string`
+    fn build_method_label(method: &MethodInfo) -> String {
+        let params: Vec<String> = method
+            .parameters
+            .iter()
+            .map(|p| {
+                let mut parts = Vec::new();
+                if let Some(ref th) = p.type_hint {
+                    parts.push(th.clone());
+                }
+                if p.is_reference {
+                    parts.push(format!("&{}", p.name));
+                } else if p.is_variadic {
+                    parts.push(format!("...{}", p.name));
+                } else {
+                    parts.push(p.name.clone());
+                }
+                let param_str = parts.join(" ");
+                if !p.is_required && !p.is_variadic {
+                    format!("{} = ...", param_str)
+                } else {
+                    param_str
+                }
+            })
+            .collect();
+
+        let ret = method
+            .return_type
+            .as_ref()
+            .map(|r| format!(": {}", r))
+            .unwrap_or_default();
+
+        format!("{}({}){}", method.name, params.join(", "), ret)
+    }
+
     /// Public helper for tests: get the ast_map for a given URI.
     pub fn get_classes_for_uri(&self, uri: &str) -> Option<Vec<ClassInfo>> {
         if let Ok(map) = self.ast_map.lock() {
@@ -329,17 +524,38 @@ impl LanguageServer for Backend {
             && let Some(offset) = Self::position_to_offset(&content, position)
             && let Some(class_info) = Self::find_class_at_offset(&classes, offset)
         {
-            let items: Vec<CompletionItem> = class_info
-                .methods
-                .iter()
-                .map(|method_name| CompletionItem {
-                    label: method_name.clone(),
+            let mut items: Vec<CompletionItem> = Vec::new();
+
+            // Add method completions
+            for method in &class_info.methods {
+                let label = Self::build_method_label(method);
+
+                items.push(CompletionItem {
+                    label,
                     kind: Some(CompletionItemKind::METHOD),
                     detail: Some(format!("Class: {}", class_info.name)),
-                    insert_text: Some(method_name.clone()),
+                    insert_text: Some(method.name.clone()),
+                    filter_text: Some(method.name.clone()),
                     ..CompletionItem::default()
-                })
-                .collect();
+                });
+            }
+
+            // Add property completions
+            for property in &class_info.properties {
+                let detail = if let Some(ref th) = property.type_hint {
+                    format!("Class: {} — {}", class_info.name, th)
+                } else {
+                    format!("Class: {}", class_info.name)
+                };
+
+                items.push(CompletionItem {
+                    label: property.name.clone(),
+                    kind: Some(CompletionItemKind::PROPERTY),
+                    detail: Some(detail),
+                    insert_text: Some(property.name.clone()),
+                    ..CompletionItem::default()
+                });
+            }
 
             if !items.is_empty() {
                 return Ok(Some(CompletionResponse::Array(items)));