Don't obtain apparent type of contextual types being optional type variables #61635
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
typescript-bot
added
the
For Uncommitted Bug
Contributor
There was a problem hiding this comment.
Pull Request Overview
This PR addresses #61633 by fixing an incorrect treatment of contextual types that are optional type variables. The changes include updating the type checker logic to use a non‑nullable version of the instantiated type when verifying type variable status, and adding corresponding tests.
Reviewed Changes
Copilot reviewed 3 out of 5 changed files in this pull request and generated 1 comment.
| File | Description |
|---|---|
| tests/cases/compiler/inferenceFromGenericClass1.ts | Adds tests to verify proper inference when using generic classes with optional type variables. |
| tests/baselines/reference/inferenceFromGenericClass1.js | Updates baseline output corresponding to the new test behavior. |
| src/compiler/checker.ts | Adjusts the type checking logic to use getNonNullableType and maybeTypeOfKind in the constraint check. |
Files not reviewed (2)
- tests/baselines/reference/inferenceFromGenericClass1.symbols: Language not supported
- tests/baselines/reference/inferenceFromGenericClass1.types: Language not supported
| getContextualType(node, contextFlags); | ||
| const instantiatedType = instantiateContextualType(contextualType, node, contextFlags); | ||
| if (instantiatedType && !(contextFlags && contextFlags & ContextFlags.NoConstraints && instantiatedType.flags & TypeFlags.TypeVariable)) { | ||
| if (instantiatedType && !(contextFlags && contextFlags & ContextFlags.NoConstraints && maybeTypeOfKind(getNonNullableType(instantiatedType), TypeFlags.TypeVariable))) { |
There was a problem hiding this comment.
This change replaces the direct check on instantiatedType.flags with a call to maybeTypeOfKind on a non-nullable version of instantiatedType. Please double-check that using getNonNullableType ensures that optional type variables are not incorrectly inferred as type variables.
Contributor
Author
There was a problem hiding this comment.
- Without this
instantiateTypeWithSingleGenericCallSignaturecomputedcontextualTypeasAnyConstructor | undefined - then eliminated
| undefinedwithgetNonNullableType - and obtained a generic
contextualSignaturefrom that - and returned
anyFunctionTypebecause this happened withCheckMode.SkipGenericFunctions - given
anyFunctionTypeis non-inferrable,getInferredTypepicked up the default type argument (undefined) - and
getSignatureApplicabilityErrorreturned with diagnostics because it was called with a check candidate that was a product of signature instantiation with currently inferred type arguments
Andarist
force-pushed
the
fix/apparent-type-of-contextual-optional-type-variable
branch
from
f29693d to
529fc9e
Compare
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
fixes #61633