feat: complete Laravel config navigation with config() helper and typed accessors

Co-authored-by: Anders Jenbo <anders@jenbo.dk>

Author: MingJen

docs/CHANGELOG.md

@@ -14,7 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Unused variable diagnostics.** Variables assigned but never read are flagged with hint severity and rendered as dimmed text. Covers local variables, foreach key/value bindings, catch variables, and closure `use` bindings. Variables named `$_` or prefixed with `$_` are exempt.
 - **Mago diagnostic proxy.** Mago lint and analyze diagnostics are surfaced as LSP diagnostics with quick-fix code actions. Configurable under `[mago]` in `.phpantom.toml`. Requires Mago 1.15+.
 - **PHPCS diagnostic proxy.** PHP_CodeSniffer violations are surfaced as LSP diagnostics with sniff-name diagnostic codes and severity mapping. Configurable under `[phpcs]` in `.phpantom.toml`.
-- **Laravel config and env key navigation.** "Go to Definition" and "Find All References" now work for string-literal config keys and env variables (`config('app.name')`, `Config::get(...)`, `env('APP_KEY')`). Contributed by @MingJen in https://github.com/AJenbo/phpantom_lsp/pull/93.
+- **Laravel config and env key navigation.** "Go to Definition" and "Find All References" now work for string-literal config keys and env variables (`config('app.name')`, `Config::get(...)`, `config()->string(...)`, `env('APP_KEY')`). Covers the `Config` facade, the `config()` helper (including fully-qualified `\config()`), and all typed accessors (`string`, `integer`, `float`, `boolean`, `array`, `collection`, `set`, `prepend`, `push`). Contributed by @MingJen in https://github.com/AJenbo/phpantom_lsp/pull/93 and https://github.com/AJenbo/phpantom_lsp/pull/96.
 - **Namespace renaming.** Renaming a namespace segment updates all namespace declarations, use statements, group use declarations, and fully-qualified name references across the workspace. When a PSR-4 autoload mapping exists, the corresponding directory is moved to keep the filesystem consistent.
 - **Linked editing ranges.** Place the cursor on a variable and all occurrences within its definition region enter linked editing mode. Typing a new name updates every occurrence simultaneously.
 - **Import all missing classes.** A bulk code action that imports every unresolved class name in the file at once. Only names with a single unambiguous candidate are imported; ambiguous names are left for manual resolution.

src/symbol_map/extraction.rs

@@ -1625,6 +1625,13 @@ fn extract_from_expression<'a>(
 
                 if let ClassLikeMemberSelector::Identifier(ident) = &method_call.method {
                     let member_name = ident.value.to_string();
+                    if is_laravel_config_repository_call(method_call.object, &member_name) {
+                        try_emit_config_key_span(
+                            &method_call.argument_list,
+                            ctx.content,
+                            &mut ctx.spans,
+                        );
+                    }
                     // Emit call site for method call: `$subject->method(...)`
                     emit_call_site(
                         format!("{}->{}", &subject_text, &member_name),
@@ -1652,6 +1659,13 @@ fn extract_from_expression<'a>(
 
                 if let ClassLikeMemberSelector::Identifier(ident) = &method_call.method {
                     let member_name = ident.value.to_string();
+                    if is_laravel_config_repository_call(method_call.object, &member_name) {
+                        try_emit_config_key_span(
+                            &method_call.argument_list,
+                            ctx.content,
+                            &mut ctx.spans,
+                        );
+                    }
                     // Emit call site for null-safe method call.
                     // Use `->` so resolve_callable handles it the same
                     // as regular method calls.
@@ -1703,20 +1717,7 @@ fn extract_from_expression<'a>(
                     if (clean_subject.eq_ignore_ascii_case("Config")
                         || clean_subject
                             .eq_ignore_ascii_case("Illuminate\\Support\\Facades\\Config"))
-                        && matches!(
-                            member_name.to_ascii_lowercase().as_str(),
-                            "has"
-                                | "get"
-                                | "string"
-                                | "integer"
-                                | "float"
-                                | "boolean"
-                                | "array"
-                                | "collection"
-                                | "set"
-                                | "prepend"
-                                | "push"
-                        )
+                        && is_config_repository_method(&member_name)
                     {
                         try_emit_config_key_span(
                             &static_call.argument_list,
@@ -2938,6 +2939,43 @@ fn try_emit_config_key_span(
     });
 }
 
+/// Returns `true` if `name` is a method on Laravel's `Repository` config contract
+/// that accepts a config key as its first argument.
+fn is_config_repository_method(name: &str) -> bool {
+    matches!(
+        name.to_ascii_lowercase().as_str(),
+        "has"
+            | "get"
+            | "string"
+            | "integer"
+            | "float"
+            | "boolean"
+            | "array"
+            | "collection"
+            | "set"
+            | "prepend"
+            | "push"
+    )
+}
+
+/// Returns `true` if `object` is a `config()` (or `\config()`) helper call and
+/// `member_name` is a config-key-accepting method, e.g. `config()->get('app.name')`.
+fn is_laravel_config_repository_call(object: &Expression<'_>, member_name: &str) -> bool {
+    if !is_config_repository_method(member_name) {
+        return false;
+    }
+
+    match object {
+        Expression::Call(Call::Function(func_call)) => match func_call.function {
+            Expression::Identifier(ident) => {
+                strip_fqn_prefix(ident.value()).eq_ignore_ascii_case("config")
+            }
+            _ => false,
+        },
+        _ => false,
+    }
+}
+
 /// Recursively check whether an expression contains an `instanceof` operator.
 fn arg_contains_instanceof(expr: &Expression<'_>) -> bool {
     match expr {

src/virtual_members/laravel/helpers_tests.rs

@@ -121,3 +121,290 @@ fn legacy_accessor_prop_name_three_words() {
         "getFullLegalNameAttribute"
     );
 }
+
+// ── walk_all_php_expressions ─────────────────────────────────────────────────
+
+fn collect_strings(php: &str) -> Vec<String> {
+    let mut found = Vec::new();
+    walk_all_php_expressions(php, &mut |expr| {
+        if let Some((s, _, _)) = extract_string_literal(expr, php) {
+            found.push(s.to_string());
+        }
+        ControlFlow::Continue(())
+    });
+    found
+}
+
+fn has(php: &str, needle: &str) -> bool {
+    collect_strings(php).iter().any(|s| s == needle)
+}
+
+// ── Statement branches ───────────────────────────────────────────────────────
+
+#[test]
+fn walker_return_stmt() {
+    assert!(has("<?php return 'ret';", "ret"));
+}
+
+#[test]
+fn walker_echo_stmt() {
+    let php = "<?php echo 'ea', 'eb';";
+    assert!(has(php, "ea"));
+    assert!(has(php, "eb"));
+}
+
+#[test]
+fn walker_namespace_stmt() {
+    assert!(has("<?php namespace Foo; return 'ns';", "ns"));
+}
+
+#[test]
+fn walker_block_stmt() {
+    assert!(has("<?php { return 'blk'; }", "blk"));
+}
+
+#[test]
+fn walker_if_stmt() {
+    let php =
+        "<?php if (true) { return 'th'; } elseif (false) { return 'ei'; } else { return 'el'; }";
+    assert!(has(php, "th"));
+    assert!(has(php, "ei"));
+    assert!(has(php, "el"));
+}
+
+#[test]
+fn walker_while_stmt() {
+    assert!(has("<?php while (true) { return 'wb'; }", "wb"));
+}
+
+#[test]
+fn walker_do_while_stmt() {
+    assert!(has("<?php do { return 'dw'; } while (false);", "dw"));
+}
+
+#[test]
+fn walker_for_stmt() {
+    let php = "<?php for (foo('fi'); foo('fc'); foo('fu')) { foo('fb'); }";
+    assert!(has(php, "fi"));
+    assert!(has(php, "fc"));
+    assert!(has(php, "fu"));
+    assert!(has(php, "fb"));
+}
+
+#[test]
+fn walker_foreach_stmt() {
+    let php = "<?php foreach (['item'] as $v) { return 'fv'; }";
+    assert!(has(php, "item"));
+    assert!(has(php, "fv"));
+}
+
+#[test]
+fn walker_try_catch_finally() {
+    let php = "<?php try { return 'tv'; } catch (\\Exception $e) { return 'cv'; } finally { return 'fv'; }";
+    assert!(has(php, "tv"));
+    assert!(has(php, "cv"));
+    assert!(has(php, "fv"));
+}
+
+#[test]
+fn walker_switch_stmt() {
+    let php = "<?php switch ('sw') { case 'cs': return 'rv'; default: return 'dv'; }";
+    assert!(has(php, "sw"));
+    assert!(has(php, "cs"));
+    assert!(has(php, "rv"));
+    assert!(has(php, "dv"));
+}
+
+#[test]
+fn walker_function_body() {
+    assert!(has("<?php function foo() { return 'fn'; }", "fn"));
+}
+
+#[test]
+fn walker_class_method_body() {
+    assert!(has("<?php class C { function m() { return 'cm'; } }", "cm"));
+}
+
+#[test]
+fn walker_class_property() {
+    assert!(has("<?php class C { public $x = 'pv'; }", "pv"));
+}
+
+#[test]
+fn walker_class_constant() {
+    assert!(has("<?php class C { const K = 'ck'; }", "ck"));
+}
+
+#[test]
+fn walker_interface_constant() {
+    assert!(has("<?php interface I { const K = 'ik'; }", "ik"));
+}
+
+#[test]
+fn walker_trait_method_body() {
+    assert!(has("<?php trait T { function m() { return 'tm'; } }", "tm"));
+}
+
+#[test]
+fn walker_enum_backed_case() {
+    assert!(has("<?php enum S: string { case A = 'ev'; }", "ev"));
+}
+
+#[test]
+fn walker_enum_constant() {
+    assert!(has("<?php enum S { const K = 'ec'; }", "ec"));
+}
+
+#[test]
+fn walker_static_var() {
+    assert!(has("<?php function f() { static $x = 'sv'; }", "sv"));
+}
+
+#[test]
+fn walker_unset_stmt() {
+    // unset args are variable expressions; verify the walker reaches code after it
+    assert!(has("<?php unset($x); return 'au';", "au"));
+}
+
+// ── Expression branches ──────────────────────────────────────────────────────
+
+#[test]
+fn walker_method_call() {
+    assert!(has("<?php $o->m('ma');", "ma"));
+}
+
+#[test]
+fn walker_null_safe_method_call() {
+    assert!(has("<?php $o?->m('na');", "na"));
+}
+
+#[test]
+fn walker_binary_expr() {
+    let php = "<?php return 'lhs' . 'rhs';";
+    assert!(has(php, "lhs"));
+    assert!(has(php, "rhs"));
+}
+
+#[test]
+fn walker_unary_prefix() {
+    assert!(has("<?php $x = !true; return 'up';", "up"));
+}
+
+#[test]
+fn walker_unary_postfix() {
+    assert!(has("<?php $i = 0; $i++; return 'upo';", "upo"));
+}
+
+#[test]
+fn walker_parenthesized() {
+    assert!(has("<?php return ('pv');", "pv"));
+}
+
+#[test]
+fn walker_assignment() {
+    assert!(has("<?php $x = 'av';", "av"));
+}
+
+#[test]
+fn walker_conditional_ternary() {
+    let php = "<?php return true ? 'th' : 'el';";
+    assert!(has(php, "th"));
+    assert!(has(php, "el"));
+}
+
+#[test]
+fn walker_conditional_elvis() {
+    let php = "<?php return 'cv' ?: 'ev';";
+    assert!(has(php, "cv"));
+    assert!(has(php, "ev"));
+}
+
+#[test]
+fn walker_array_literal() {
+    let php = "<?php return ['v1', 'k' => 'v2'];";
+    assert!(has(php, "v1"));
+    assert!(has(php, "k"));
+    assert!(has(php, "v2"));
+}
+
+#[test]
+fn walker_legacy_array() {
+    assert!(has("<?php return array('la1', 'la2');", "la1"));
+}
+
+#[test]
+fn walker_variadic_array_element() {
+    assert!(has("<?php return [...$a, 'vae'];", "vae"));
+}
+
+#[test]
+fn walker_array_access() {
+    assert!(has("<?php return $a['ki'];", "ki"));
+}
+
+#[test]
+fn walker_closure_body() {
+    assert!(has("<?php $f = function() { return 'clv'; };", "clv"));
+}
+
+#[test]
+fn walker_arrow_function() {
+    assert!(has("<?php $f = fn() => 'afv';", "afv"));
+}
+
+#[test]
+fn walker_match_expr() {
+    let php = "<?php return match ('ms') { 'ma' => 'mv', default => 'md' };";
+    assert!(has(php, "ms"));
+    assert!(has(php, "ma"));
+    assert!(has(php, "mv"));
+    assert!(has(php, "md"));
+}
+
+#[test]
+fn walker_throw_expr() {
+    assert!(has("<?php throw new \\Exception('te');", "te"));
+}
+
+#[test]
+fn walker_yield_value() {
+    assert!(has("<?php function g() { yield 'yv'; }", "yv"));
+}
+
+#[test]
+fn walker_yield_pair() {
+    let php = "<?php function g() { yield 'yk' => 'yp'; }";
+    assert!(has(php, "yk"));
+    assert!(has(php, "yp"));
+}
+
+#[test]
+fn walker_yield_from() {
+    assert!(has("<?php function g() { yield from ['yf']; }", "yf"));
+}
+
+#[test]
+fn walker_clone() {
+    assert!(has("<?php $b = clone $a; return 'after';", "after"));
+}
+
+#[test]
+fn walker_instantiation_args() {
+    assert!(has("<?php new Foo('ca');", "ca"));
+}
+
+// ── ControlFlow early exit ───────────────────────────────────────────────────
+
+#[test]
+fn walker_early_exit_stops_after_break() {
+    let php = "<?php foo('a'); foo('b'); foo('c');";
+    let mut visited: Vec<String> = Vec::new();
+    walk_all_php_expressions(php, &mut |expr| {
+        if let Some((s, _, _)) = extract_string_literal(expr, php) {
+            visited.push(s.to_string());
+            return ControlFlow::Break(());
+        }
+        ControlFlow::Continue(())
+    });
+    assert_eq!(visited, vec!["a".to_string()]);
+}