feat: infer config() return types from project config files

calebdw · calebdw · commit a7ccd328abe6 · 2026-07-25T00:14:22.000-05:00
Parse Laravel config/*.php files into typed trees and use them to
infer return types for config(), Config::get(), and
Repository::get() calls with static string keys. Scalar values
widen to their base type (string, int, bool), env() defaults resolve
through the fallback argument, and nested arrays become array shapes.

The parsed trees are cached alongside config keys and invalidated
when config files change, so no filesystem access happens on the
hot completion/hover path.
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Config return type inference.** `config('database.default')`, `Config::get('app.name')`, and `$repository->get('mail.from')` now infer their return type from the project's `config/*.php` files. Scalar values resolve to their base type (`string`, `int`, `bool`), `env()` defaults resolve through their fallback argument, and nested arrays resolve to array shapes with typed keys. Parsed config trees are cached and invalidated when config files change. Contributed by @calebdw.
 - **Semantic token modes.** `.phpantom.toml` now supports `[semantic_tokens] mode = "contextual" | "full" | "off"`. The default `contextual` mode emits only context-sensitive highlighting that complements editor syntax grammars, while `full` keeps the previous broad semantic-token stream and `off` disables semantic tokens. Contributed by @calebdw.
 - **`@phpstan-ignore` identifiers are highlighted and completed.** PHPStan ignore comments now highlight the `@phpstan-ignore` tag and each listed error identifier in both docblocks and ordinary `//` comments. Identifier completion works inside the comma-separated ignore list, using PHPStan diagnostic codes already seen in the current file while staying out of per-code parenthesized reasons. Contributed by @calebdw.
 - **Parent member override completion.** Typing a method name after `function` in a class body (for example `protected function get`) now suggests public and protected methods from parent classes and interfaces that can still be overridden or implemented, inserting a full signature snippet. The same flow suggests parent properties after `$` (for example `protected $tit`) and parent constants after `const`. Snippets insert `#[\Override]` above methods on PHP 8.3+, properties on PHP 8.5+, and constants on PHP 8.6+ (from `composer.json` / `config.platform.php`). Private members and ones already defined on the class are omitted. Contributed by @calebdw.
diff --git a/src/analyse/run.rs b/src/analyse/run.rs
@@ -305,9 +305,11 @@ pub async fn run(options: AnalyseOptions) -> i32 {
                             let class_loader = backend.class_loader(&file_ctx);
                             let function_loader_cl = backend.function_loader(&file_ctx);
                             let constant_loader_cl = backend.constant_loader();
+                            let config_resolver = |key: &str| backend.resolve_config_type(key);
                             let loaders = crate::type_engine::resolver::Loaders {
                                 function_loader: Some(&function_loader_cl),
                                 constant_loader: Some(&constant_loader_cl),
+                                config_resolver: Some(&config_resolver),
                             };
                             crate::type_engine::variable::forward_walk::build_diagnostic_scopes(
                                 content,
diff --git a/src/code_actions/extract_function/scope.rs b/src/code_actions/extract_function/scope.rs
@@ -28,11 +28,13 @@ pub(crate) fn resolve_var_type(
     let class_loader = backend.class_loader(&ctx);
     let function_loader = backend.function_loader(&ctx);
     let constant_loader = backend.constant_loader();
+    let config_resolver = |key: &str| backend.resolve_config_type(key);
     let loaders = Loaders {
         function_loader: Some(
             &function_loader as &dyn Fn(&str, u32) -> Option<crate::types::FunctionInfo>,
         ),
         constant_loader: Some(&constant_loader),
+        config_resolver: Some(&config_resolver),
     };
 
     let current_class = find_class_at_offset(&ctx.classes, cursor_offset);
diff --git a/src/diagnostics/mod.rs b/src/diagnostics/mod.rs
@@ -289,9 +289,11 @@ impl Backend {
             let class_loader = self.class_loader(&ctx.file);
             let function_loader_cl = self.function_loader(&ctx.file);
             let constant_loader_cl = self.constant_loader();
+            let config_resolver = |key: &str| self.resolve_config_type(key);
             let loaders = crate::type_engine::resolver::Loaders {
                 function_loader: Some(&function_loader_cl),
                 constant_loader: Some(&constant_loader_cl),
+                config_resolver: Some(&config_resolver),
             };
             crate::type_engine::variable::forward_walk::build_diagnostic_scopes(
                 content,
diff --git a/src/diagnostics/property_type_errors.rs b/src/diagnostics/property_type_errors.rs
@@ -344,9 +344,11 @@ fn check_expression_for_property_assignment(expr: &Expression<'_>, ctx: &mut Pro
     let rhs_start = rhs_span.start.offset as usize;
     let rhs_end = rhs_span.end.offset as usize;
 
+    let config_resolver = |key: &str| ctx.backend.resolve_config_type(key);
     let loaders = Loaders {
         function_loader: Some(ctx.function_loader),
         constant_loader: Some(ctx.constant_loader),
+        config_resolver: Some(&config_resolver),
     };
 
     let var_ctx = VarResolutionCtx {
diff --git a/src/diagnostics/return_type_errors.rs b/src/diagnostics/return_type_errors.rs
@@ -477,9 +477,11 @@ fn process_top_level_statement(
             let enclosing = find_innermost_enclosing_class(&file_ctx.classes, func_offset);
             let current_class = enclosing.unwrap_or(default_class);
 
+            let config_resolver = |key: &str| backend.resolve_config_type(key);
             let loaders = Loaders {
                 function_loader: Some(function_loader),
                 constant_loader: Some(constant_loader),
+                config_resolver: Some(&config_resolver),
             };
 
             for (maybe_expr, start, end) in returns {
@@ -613,9 +615,11 @@ fn process_class_member(
             }
         });
 
+    let config_resolver = |key: &str| backend.resolve_config_type(key);
     let loaders = Loaders {
         function_loader: Some(function_loader),
         constant_loader: Some(constant_loader),
+        config_resolver: Some(&config_resolver),
     };
 
     for (maybe_expr, start, end) in returns {
diff --git a/src/diagnostics/type_errors/mod.rs b/src/diagnostics/type_errors/mod.rs
@@ -311,9 +311,11 @@ impl Backend {
                     let enclosing = find_innermost_enclosing_class(&file_ctx.classes, *args_start);
                     let current_class_info = enclosing.unwrap_or(&default_class);
 
+                    let config_resolver = |key: &str| self.resolve_config_type(key);
                     let loaders = Loaders {
                         function_loader: Some(&function_loader_cl),
                         constant_loader: Some(&constant_loader_cl),
+                        config_resolver: Some(&config_resolver),
                     };
 
                     let var_ctx = VarResolutionCtx {
diff --git a/src/hover/variable.rs b/src/hover/variable.rs
@@ -70,9 +70,11 @@ impl Backend {
         let class_loader = self.class_loader(ctx);
         let function_loader = self.function_loader(ctx);
         let constant_loader = self.constant_loader();
+        let config_resolver = |key: &str| self.resolve_config_type(key);
         let loaders = crate::type_engine::resolver::Loaders {
             function_loader: Some(&function_loader as &dyn Fn(&str, u32) -> Option<FunctionInfo>),
             constant_loader: Some(&constant_loader),
+            config_resolver: Some(&config_resolver),
         };
 
         // Try the type-string path first.  This preserves generic
diff --git a/src/lib.rs b/src/lib.rs
@@ -314,6 +314,12 @@ pub(crate) struct LaravelStringKeyCache {
     pub config_keys: Option<Vec<String>>,
     pub view_names: Option<Vec<String>>,
     pub trans_keys: Option<Vec<String>>,
+    pub config_trees: Option<
+        Vec<(
+            String,
+            crate::virtual_members::laravel::config_values::ConfigNode,
+        )>,
+    >,
 }
 
 impl LaravelStringKeyCache {
@@ -323,6 +329,7 @@ impl LaravelStringKeyCache {
         }
         if uri.contains("/config/") {
             self.config_keys = None;
+            self.config_trees = None;
         }
         // View roots are configurable via `config/view.php`, so a Blade
         // file may live outside `resources/views/`. Invalidate on any
diff --git a/src/server.rs b/src/server.rs
@@ -2414,6 +2414,7 @@ impl Backend {
         if config_count + view_count + trans_count + route_count > 0 {
             let mut cache = self.laravel_string_key_cache.write();
             cache.config_keys = None;
+            cache.config_trees = None;
             cache.view_names = None;
             cache.trans_keys = None;
             cache.route_names = None;
diff --git a/src/type_engine/resolver/context.rs b/src/type_engine/resolver/context.rs
@@ -80,6 +80,11 @@ pub(crate) type FunctionLoaderFn<'a> = Option<&'a dyn Fn(&str, u32) -> Option<Fu
 /// when the constant was not found.
 pub(crate) type ConstantLoaderFn<'a> = Option<&'a dyn Fn(&str) -> Option<Option<String>>>;
 
+/// Type alias for the optional config-value resolver closure.  Given a
+/// dotted Laravel config key (e.g. `"database.default"`), returns the
+/// inferred [`PhpType`] of the config value.
+pub(crate) type ConfigResolverFn<'a> = Option<&'a dyn Fn(&str) -> Option<crate::php_type::PhpType>>;
+
 /// Type alias for the optional scope-based variable resolver from the
 /// forward walker.  When set on a [`VarResolutionCtx`], variable
 /// lookups read from the forward walker's in-progress `ScopeState`
@@ -103,6 +108,10 @@ pub(crate) struct Loaders<'a> {
     /// constant's value string so that the type can be inferred from
     /// the literal value.
     pub constant_loader: ConstantLoaderFn<'a>,
+    /// Resolve a dotted Laravel config key (e.g. `"database.default"`)
+    /// to the inferred type of its static value.  Used by the
+    /// `config()` return-type interception in function call resolution.
+    pub config_resolver: ConfigResolverFn<'a>,
 }
 
 impl<'a> Loaders<'a> {
@@ -111,6 +120,7 @@ impl<'a> Loaders<'a> {
         Self {
             function_loader: fl,
             constant_loader: None,
+            config_resolver: None,
         }
     }
 }
diff --git a/src/type_engine/variable/rhs_resolution/calls.rs b/src/type_engine/variable/rhs_resolution/calls.rs
@@ -800,6 +800,27 @@ pub(super) fn resolve_rhs_function_call<'b>(
         }
     }
 
+    // ── Laravel config() return type inference ───────
+    if let Some(ref name) = func_name {
+        let normalized_func = name.trim_start_matches('\\');
+        if matches!(normalized_func, "config" | "Illuminate\\Support\\config") {
+            let arg_texts =
+                crate::type_engine::variable::raw_type_inference::extract_arg_texts_from_ast(
+                    &func_call.argument_list,
+                    content,
+                );
+            if let Some(first_arg) = arg_texts.first()
+                && let Some(key) = crate::util::unescape_php_string_literal(first_arg.trim())
+                && !key.is_empty()
+                && !key.contains('$')
+                && let Some(resolver) = ctx.loaders.config_resolver
+                && let Some(ty) = resolver(&key)
+            {
+                return vec![ResolvedType::from_type_string(ty)];
+            }
+        }
+    }
+
     // ── Known array functions ────────────────────────
     // For element-extracting functions (array_pop, etc.)
     // resolve to the element ClassInfo directly.
@@ -1185,6 +1206,14 @@ pub(super) fn resolve_rhs_method_call_inner<'b>(
     let (owner_classes, receiver_resolved) =
         expand_union_generic_owners(owner_classes, receiver_resolved, ctx);
 
+    for owner in &owner_classes {
+        if let Some(result) =
+            try_resolve_config_method_type(&owner.fqn(), &method_name, argument_list, ctx)
+        {
+            return result;
+        }
+    }
+
     let is_union = owner_classes.len() > 1;
     let mut union_results: Vec<ResolvedType> = Vec::new();
 
@@ -1948,6 +1977,15 @@ pub(super) fn resolve_rhs_static_call(
             };
             let owner = concrete_owner.as_ref().unwrap_or(owner);
 
+            if let Some(result) = try_resolve_config_method_type(
+                &owner.fqn(),
+                &method_name,
+                &static_call.argument_list,
+                ctx,
+            ) {
+                return result;
+            }
+
             let arg_texts =
                 crate::type_engine::variable::raw_type_inference::extract_arg_texts_from_ast(
                     &static_call.argument_list,
@@ -2037,6 +2075,47 @@ fn facade_accessor_concrete_owner(
         })
 }
 
+fn try_resolve_config_method_type(
+    owner_fqn: &str,
+    method_name: &str,
+    argument_list: &ArgumentList<'_>,
+    ctx: &VarResolutionCtx<'_>,
+) -> Option<Vec<ResolvedType>> {
+    const CONFIG_FQNS: &[&str] = &[
+        "Illuminate\\Config\\Repository",
+        "Illuminate\\Support\\Facades\\Config",
+        "Config",
+    ];
+    if !matches!(method_name, "get" | "array") {
+        return None;
+    }
+    let normalized = owner_fqn.strip_prefix('\\').unwrap_or(owner_fqn);
+    if !CONFIG_FQNS
+        .iter()
+        .any(|fqn| normalized.eq_ignore_ascii_case(fqn))
+    {
+        return None;
+    }
+    let resolver = ctx.loaders.config_resolver?;
+    let arg_texts = crate::type_engine::variable::raw_type_inference::extract_arg_texts_from_ast(
+        argument_list,
+        ctx.content,
+    );
+    let first_arg = arg_texts.first()?;
+    let key = crate::util::unescape_php_string_literal(first_arg.trim())?;
+    if key.is_empty() || key.contains('$') {
+        return None;
+    }
+    let ty = resolver(&key)?;
+    if method_name == "array" {
+        if ty.is_array_like() {
+            return Some(vec![ResolvedType::from_type_string(ty)]);
+        }
+        return None;
+    }
+    Some(vec![ResolvedType::from_type_string(ty)])
+}
+
 fn facade_accessor_class_name(ty: &PhpType) -> Option<String> {
     match ty {
         PhpType::ClassString(Some(inner)) => inner.base_name().map(ToString::to_string),
diff --git a/src/virtual_members/laravel/config_values.rs b/src/virtual_members/laravel/config_values.rs
diff --git a/tests/integration/hover.rs b/tests/integration/hover.rs

Original file line number	Diff line number	Diff line change
`@@ -314,6 +314,12 @@ pub(crate) struct LaravelStringKeyCache {`
`314`	`314`	`pub config_keys: Option<Vec<String>>,`
`315`	`315`	`pub view_names: Option<Vec<String>>,`
`316`	`316`	`pub trans_keys: Option<Vec<String>>,`
	`317`	`+ pub config_trees: Option<`
	`318`	`+ Vec<(`
	`319`	`+ String,`
	`320`	`+ crate::virtual_members::laravel::config_values::ConfigNode,`
	`321`	`+ )>,`
	`322`	`+ >,`
`317`	`323`	`}`
`318`	`324`
`319`	`325`	`impl LaravelStringKeyCache {`
`@@ -323,6 +329,7 @@ impl LaravelStringKeyCache {`
`323`	`329`	`}`
`324`	`330`	`if uri.contains("/config/") {`
`325`	`331`	`self.config_keys = None;`
	`332`	`+ self.config_trees = None;`
`326`	`333`	`}`
`327`	`334`	// View roots are configurable via `config/view.php`, so a Blade
`328`	`335`	// file may live outside `resources/views/`. Invalidate on any