[Yusuf YILDIZ (yusufyildiz34)]

Fixes #63785

Analysis

When the language service needs a contextual type for completions, it calls GetContextualType with ContextFlagsIgnoreNodeInferences. That marks the node being edited and its ancestors up to the containing call as "skip direct inference". isFromInferenceBlockedSource then decides whether a source type is blocked by checking whether the type's symbol is declared by one of those nodes.

That works for object literals, but array literal types have no symbol pointing back to their node. They are also cached and shared between array literals that have identical element types. So in

type AllPartialObject = { component?: string }
declare function extendTheme1<Extensions extends [AllPartialObject]>(extensions: Extensions): void

extendTheme1([{ /*|*/ }])

the array literal [{}] is still used as an inference source for Extensions. The "completions" contextual type therefore becomes {} instead of the constraint AllPartialObject, and component is not offered.

The cases from the issue that already worked did so by accident:

• extendTheme3([{}]): [{}] is not assignable to the constraint (it is missing requiredField), so inference falls back to the constraint.
• extendTheme5: the parameter is [Extensions], so inference goes through the element {}, which does have a symbol.

Once requiredField: 'foo' is filled in, the inferred type satisfies the constraint and completions regress again. The same happens with plain array constraints such as T extends X[], and with arrays nested in object arguments (f({ items: [{ /*|*/ }] }) with f<T extends X[]>(o: { items: T })).

Fix

• In createArrayLiteralType, if the array literal node is in skipDirectInferenceNodes, create a distinct (uncached) array literal type and record it in a new skipDirectInferenceTypes set.
• isFromInferenceBlockedSource also treats types in that set as blocked.
• runWithInferenceBlockedFromSourceNode clears the set together with skipDirectInferenceNodes.

This only has an effect while the language service is running a query with inference blocked. Regular type checking is unchanged, and no compiler or fourslash baselines changed.

I also considered blocking an array literal type when one of its element types comes from a blocked source. That approach is fragile: it misses union-reduced element types and non-object elements. It also wouldn't handle arrays nested in object literals as directly as recording the type.

A new fourslash test, completionsObjectLiteralInGenericTupleConstraint, covers all the cases from the issue, a plain array constraint, and an array nested in an object argument.

Checklist

• Code is up-to-date with the main branch
• npx hereby test
• npx hereby validate (build, test, lint, format)
• New tests validating the change

[Yusuf YILDIZ (yusufyildiz34)]

@microsoft-github-policy-service agree

[Copilot]

🟢 Approval recommended

No active review issues require further changes.

No open issues 🎉

What changed in this PR

Fixes #63785 by preventing array literals from driving inference during completion contextual-type queries, restoring property suggestions for generic tuple and array constraints.

Changes:

• Creates distinct array literal types for blocked inference sources and tracks them explicitly.
• Recognizes those types during inference and clears tracking after the query.
• Adds fourslash coverage for tuple constraints, array constraints, and arrays nested in object arguments.

File	Description
tsc/​internal/​fourslash/​tests/​completionsObjectLiteralInGenericTupleConstraint_test.go	Tests property completions across eight constraint scenarios.
tsc/​internal/​checker/​services.go	Clears blocked-type tracking after contextual-type queries.
tsc/​internal/​checker/​inference.go	Recognizes explicitly tracked types as blocked inference sources.
tsc/​internal/​checker/​checker.go	Creates and tracks distinct types for inference-blocked array literals.

_{Review effort: Balanced}