…metersFixesmicrosoft#62693## ProblemWhen a generic function has overloads with mixed parameter types (function vs object literal), TypeScript shows incorrect completions for object literals. For example:```typescriptdeclare function task<T>(make: () => T): voiddeclare function task<T>(arg: {make: () => T}): voidtask({    // BUG: Shows bind, call, apply instead of "make"})```The editor shows function properties (bind, call, apply) instead of the expected object property "make".## Root CauseDuring completion, generic type inference is blocked (type parameters are unknown). When `chooseOverload` evaluates candidates, it:1. Attempts to resolve the function-type overload first2. Cannot infer `T` during completion context3. Falls back to treating the object literal as a function type4. Returns function properties instead of object propertiesThe issue occurs because overload selection doesn't account for the syntactic context (completing an object literal) when generic inference is unavailable.## SolutionThe fix tracks which argument position is being completed and uses this information during overload resolution to prefer object-type overloads when completing object literals.### Changes**types.ts (line 6311):**Added `completionArgumentIndex` to NodeLinks to track which argument is being completed.**checker.ts (lines 32072-32076):**Store the argument index when inference is blocked during completion:```typescriptif (isInferencePartiallyBlocked) {    links.completionArgumentIndex = argIndex;}```**checker.ts (lines 36728-36832):**Enhanced `chooseOverload` to:1. Detect when completing an object literal at argument position 02. Skip overload candidates with function-type parameters3. Accept object-type overload candidates even if the literal is incompleteThis allows the type checker to select the correct overload based on syntactic context rather than relying solely on type inference.## Why This WorksThe fix is surgical and only affects generic overload resolution during completion:- **Targeted scope:** Only triggers for object literals at argument 0 with blocked inference- **Preserved behavior:** Non-generic overloads and other arguments remain unchanged- **Syntactic guidance:** Uses the object literal syntax to disambiguate overloads when type inference is unavailableThe approach respects TypeScript's existing completion infrastructure while providing better overload selection for this specific edge case.## TestingAdded comprehensive test coverage in `completionForGenericOverloadObjectLiteral.ts`:- Generic function-first overload (the bug)- Generic object-first overload (control)- Non-generic overload (control)- Multiple type parameters with optional properties (rigorous)All tests verify that object properties appear in completions and function properties (bind, call, apply) are correctly excluded.Test results: 99,000 passing, 0 regressions