From 40905d43a5a154db780418eea82f462bdcac7987 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Sat, 23 Dec 2023 23:27:20 +0100 Subject: [PATCH 1/2] Fixed inferred type widening with contextual types created by binding patterns --- src/compiler/checker.ts | 71 ++++++-- ...tternContextualTypeDoesNotCauseWidening.js | 11 -- ...ternContextualTypeDoesNotCauseWidening1.js | 11 ++ ...ntextualTypeDoesNotCauseWidening1.symbols} | 40 ++--- ...ContextualTypeDoesNotCauseWidening1.types} | 6 +- ...ontextualTypeDoesNotCauseWidening2.symbols | 164 +++++++++++++++++ ...nContextualTypeDoesNotCauseWidening2.types | 168 ++++++++++++++++++ ...estructuringShorthandAssigment2.errors.txt | 4 +- ...structuringObjectLiteralPattern.errors.txt | 16 +- ...tructuringObjectLiteralPattern1.errors.txt | 16 +- .../declarationsAndAssignments.errors.txt | 16 +- .../declarationsAndAssignments.types | 10 +- ...redLateBoundNameHasCorrectTypes.errors.txt | 4 +- ...ructuredLateBoundNameHasCorrectTypes.types | 4 +- .../destructuringFromUnionSpread.types | 4 +- ...ectBindingPatternAndAssignment3.errors.txt | 4 +- ...ngObjectBindingPatternAndAssignment3.types | 2 +- .../reference/destructuringSpread.types | 4 +- ...Pattern(nouncheckedindexedaccess=false).js | 47 +++++ ...rn(nouncheckedindexedaccess=false).symbols | 116 ++++++++++++ ...tern(nouncheckedindexedaccess=false).types | 125 +++++++++++++ ...gPattern(nouncheckedindexedaccess=true).js | 47 +++++ ...ern(nouncheckedindexedaccess=true).symbols | 116 ++++++++++++ ...ttern(nouncheckedindexedaccess=true).types | 125 +++++++++++++ .../reference/inferTupleFromBindingPattern.js | 9 - .../inferTupleFromBindingPattern.symbols | 16 -- .../inferTupleFromBindingPattern.types | 19 -- .../missingAndExcessProperties.errors.txt | 24 +-- .../missingAndExcessProperties.types | 22 +-- ...ernContextualTypeDoesNotCauseWidening1.ts} | 2 +- ...ternContextualTypeDoesNotCauseWidening2.ts | 40 +++++ .../compiler/inferTupleFromBindingPattern.ts | 28 +++ ...xtualTypeDoesNotCauseWideningFourslash1.ts | 21 +++ ...xtualTypeDoesNotCauseWideningFourslash2.ts | 21 +++ ...xtualTypeDoesNotCauseWideningFourslash3.ts | 21 +++ .../fourslash/codeFixAddMissingMember20.ts | 2 +- .../codeFixInferFromUsageJSDestructuring.ts | 2 +- 37 files changed, 1195 insertions(+), 163 deletions(-) delete mode 100644 tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.js create mode 100644 tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.js rename tests/baselines/reference/{bindingPatternContextualTypeDoesNotCauseWidening.symbols => bindingPatternContextualTypeDoesNotCauseWidening1.symbols} (72%) rename tests/baselines/reference/{bindingPatternContextualTypeDoesNotCauseWidening.types => bindingPatternContextualTypeDoesNotCauseWidening1.types} (81%) create mode 100644 tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening2.symbols create mode 100644 tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening2.types create mode 100644 tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).js create mode 100644 tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).symbols create mode 100644 tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).types create mode 100644 tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).js create mode 100644 tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).symbols create mode 100644 tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).types delete mode 100644 tests/baselines/reference/inferTupleFromBindingPattern.js delete mode 100644 tests/baselines/reference/inferTupleFromBindingPattern.symbols delete mode 100644 tests/baselines/reference/inferTupleFromBindingPattern.types rename tests/cases/compiler/{bindingPatternContextualTypeDoesNotCauseWidening.ts => bindingPatternContextualTypeDoesNotCauseWidening1.ts} (62%) create mode 100644 tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening2.ts create mode 100644 tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash1.ts create mode 100644 tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash2.ts create mode 100644 tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash3.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 43cff3cb52388..83829cee9bf08 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1968,10 +1968,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { var blockedStringType = createIntrinsicType(TypeFlags.Any, "any", /*objectFlags*/ undefined, "blocked string"); var errorType = createIntrinsicType(TypeFlags.Any, "error"); var unresolvedType = createIntrinsicType(TypeFlags.Any, "unresolved"); - var nonInferrableAnyType = createIntrinsicType(TypeFlags.Any, "any", ObjectFlags.ContainsWideningType, "non-inferrable"); var intrinsicMarkerType = createIntrinsicType(TypeFlags.Any, "intrinsic"); var unknownType = createIntrinsicType(TypeFlags.Unknown, "unknown"); var nonNullUnknownType = createIntrinsicType(TypeFlags.Unknown, "unknown", /*objectFlags*/ undefined, "non-null"); + var nonInferrableUnknownType = createIntrinsicType(TypeFlags.Unknown, "unknown", ObjectFlags.ContainsWideningType, "non-inferrable"); var undefinedType = createIntrinsicType(TypeFlags.Undefined, "undefined"); var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(TypeFlags.Undefined, "undefined", ObjectFlags.ContainsWideningType, "widening"); var missingType = createIntrinsicType(TypeFlags.Undefined, "undefined", /*objectFlags*/ undefined, "missing"); @@ -11444,10 +11444,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { reportImplicitAny(element, anyType); } // When we're including the pattern in the type (an indication we're obtaining a contextual type), we - // use a non-inferrable any type. Inference will never directly infer this type, but it is possible + // use a non-inferrable unknown type. Inference will never directly infer this type, but it is possible // to infer a type that contains it, e.g. for a binding pattern like [foo] or { foo }. In such cases, - // widening of the binding pattern type substitutes a regular any for the non-inferrable any. - return includePatternInType ? nonInferrableAnyType : anyType; + // widening of the binding pattern type substitutes a regular any for the non-inferrable unknown. + return includePatternInType ? nonInferrableUnknownType : anyType; } // Return the type implied by an object binding pattern @@ -20905,7 +20905,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function isSimpleTypeRelatedTo(source: Type, target: Type, relation: Map, errorReporter?: ErrorReporter) { const s = source.flags; const t = target.flags; - if (t & TypeFlags.Any || s & TypeFlags.Never || source === wildcardType) return true; + if (t & TypeFlags.Any || s & TypeFlags.Never || source === wildcardType || source === nonInferrableUnknownType) return true; if (t & TypeFlags.Unknown && !(relation === strictSubtypeRelation && s & TypeFlags.Any)) return true; if (t & TypeFlags.Never) return false; if (s & TypeFlags.StringLike && t & TypeFlags.String) return true; @@ -24603,6 +24603,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } else if (isObjectLiteralType(type)) { result = getWidenedTypeOfObjectLiteral(type, context); + if (type.pattern) { + result.pattern = type.pattern; + } } else if (type.flags & TypeFlags.Union) { const unionContext = context || createWideningContext(/*parent*/ undefined, /*propertyName*/ undefined, (type as UnionType).types); @@ -24617,6 +24620,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } else if (isArrayOrTupleType(type)) { result = createTypeReference(type.target, sameMap(getTypeArguments(type), getWidenedType)); + if (type.pattern) { + result.pattern = type.pattern; + } } if (result && context === undefined) { type.widened = result; @@ -25025,14 +25031,24 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // For arrays and tuples we infer new arrays and tuples where the reverse mapping has been // applied to the element type(s). if (isArrayType(source)) { - return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source)); + let reversed = createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source)) as TypeReference; + if (source.pattern) { + reversed = cloneTypeReference(reversed); + reversed.pattern = source.pattern; + } + return reversed; } if (isTupleType(source)) { const elementTypes = map(getElementTypes(source), t => inferReverseMappedType(t, target, constraint)); const elementFlags = getMappedTypeModifiers(target) & MappedTypeModifiers.IncludeOptional ? sameMap(source.target.elementFlags, f => f & ElementFlags.Optional ? ElementFlags.Required : f) : source.target.elementFlags; - return createTupleType(elementTypes, elementFlags, source.target.readonly, source.target.labeledElementDeclarations); + let reversed = createTupleType(elementTypes, elementFlags, source.target.readonly, source.target.labeledElementDeclarations) as TypeReference; + if (source.pattern) { + reversed = cloneTypeReference(reversed); + reversed.pattern = source.pattern; + } + return reversed; } // For all other object types we infer a new object type where the reverse mapping has been // applied to the type of each property. @@ -25040,6 +25056,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { reversed.source = source; reversed.mappedType = target; reversed.constraintType = constraint; + if (source.pattern) { + reversed.pattern = source.pattern; + } return reversed; } @@ -25056,7 +25075,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const templateType = getTemplateTypeFromMappedType(target); const inference = createInferenceInfo(typeParameter); inferTypes([inference], sourceType, templateType); - return getTypeFromInference(inference) || unknownType; + return getTypeFromInference(inference) || (sourceType.pattern ? nonInferrableUnknownType : unknownType); } function* getUnmatchedProperties(source: Type, target: Type, requireOptionalProperties: boolean, matchDiscriminantProperties: boolean): IterableIterator { @@ -25089,8 +25108,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function tupleTypesDefinitelyUnrelated(source: TupleTypeReference, target: TupleTypeReference) { - return !(target.target.combinedFlags & ElementFlags.Variadic) && target.target.minLength > source.target.minLength || - !target.target.hasRestElement && (source.target.hasRestElement || target.target.fixedLength < source.target.fixedLength); + return !source.pattern && (!(target.target.combinedFlags & ElementFlags.Variadic) && target.target.minLength > source.target.minLength || + !target.target.hasRestElement && (source.target.hasRestElement || target.target.fixedLength < source.target.fixedLength)); } function typesDefinitelyUnrelated(source: Type, target: Type) { @@ -25396,9 +25415,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // This flag is infectious; if we produce Box (where never is silentNeverType), Box is // also non-inferrable. // - // As a special case, also ignore nonInferrableAnyType, which is a special form of the any type - // used as a stand-in for binding elements when they are being inferred. - if (getObjectFlags(source) & ObjectFlags.NonInferrableType || source === nonInferrableAnyType) { + // As a special case, also ignore nonInferrableUnknownType, which is a special form of the unknown type + // used as a stand-in for binding elements when they are being inferred. It is ignored as a direct inference candidate + // but types containing it can be inferred. + if (getObjectFlags(source) & ObjectFlags.NonInferrableType || source === nonInferrableUnknownType) { return; } if (!inference.isFixed) { @@ -26099,12 +26119,17 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function getInferredType(context: InferenceContext, index: number): Type { const inference = context.inferences[index]; if (!inference.inferredType) { + let isFromBindingPattern = false; let inferredType: Type | undefined; let fallbackType: Type | undefined; if (context.signature) { const inferredCovariantType = inference.candidates ? getCovariantInference(inference, context.signature) : undefined; const inferredContravariantType = inference.contraCandidates ? getContravariantInference(inference) : undefined; - if (inferredCovariantType || inferredContravariantType) { + if (!inferredContravariantType && inference.candidates?.length === 1 && inference.candidates[0].pattern) { + isFromBindingPattern = true; + inferredType = inferredCovariantType; + } + else if (inferredCovariantType || inferredContravariantType) { // If we have both co- and contra-variant inferences, we prefer the co-variant inference if it is not 'never', // all co-variant inferences are subtypes of it (i.e. it isn't one of a conflicting set of candidates), it is // a subtype of some contra-variant inference, and no other type parameter is constrained to this type parameter @@ -26145,7 +26170,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const constraint = getConstraintOfTypeParameter(inference.typeParameter); if (constraint) { const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper); - if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) { + if (isFromBindingPattern) { + inference.inferredType = getIntersectionType([inference.inferredType, instantiatedConstraint]); + } + else if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) { // If the fallback type satisfies the constraint, we pick it. Otherwise, we pick the constraint. inference.inferredType = fallbackType && context.compareTypes(fallbackType, getTypeWithThisArgument(instantiatedConstraint, fallbackType)) ? fallbackType : instantiatedConstraint; } @@ -30279,7 +30307,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { else if (t.flags & TypeFlags.StructuredType) { const prop = getPropertyOfType(t, name); if (prop) { - return isCircularMappedProperty(prop) ? undefined : removeMissingType(getTypeOfSymbol(prop), !!(prop && prop.flags & SymbolFlags.Optional)); + if (isCircularMappedProperty(prop)) { + return undefined; + } + const type = getTypeOfSymbol(prop); + if (type !== nonInferrableUnknownType) { + return removeMissingType(type, !!(prop && prop.flags & SymbolFlags.Optional)); + } + if (t.flags & TypeFlags.Intersection) { + t = getIntersectionType((t as IntersectionType).types.filter(t => !t.pattern)); + } } if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) { const restType = getElementTypeOfSliceOfTupleType(t, t.target.fixedLength, /*endSkipCount*/ 0, /*writing*/ false, /*noReductions*/ true); @@ -31248,7 +31285,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { pushCachedContextualType(node); const contextualType = getApparentTypeOfContextualType(node, /*contextFlags*/ undefined); - const contextualTypeHasPattern = contextualType && contextualType.pattern && + const contextualTypeHasPattern = !(checkMode & CheckMode.Inferential) && contextualType && contextualType.pattern && (contextualType.pattern.kind === SyntaxKind.ObjectBindingPattern || contextualType.pattern.kind === SyntaxKind.ObjectLiteralExpression); const inConstContext = isConstContext(node); const checkFlags = inConstContext ? CheckFlags.Readonly : 0; diff --git a/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.js b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.js deleted file mode 100644 index 8ae5cb7067453..0000000000000 --- a/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.js +++ /dev/null @@ -1,11 +0,0 @@ -//// [tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening.ts] //// - -//// [bindingPatternContextualTypeDoesNotCauseWidening.ts] -declare function pick(keys: T[], obj?: O): Pick; -const _ = pick(['b'], { a: 'a', b: 'b' }); // T: "b" -const { } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" | "a" ??? (before fix) - - -//// [bindingPatternContextualTypeDoesNotCauseWidening.js] -var _ = pick(['b'], { a: 'a', b: 'b' }); // T: "b" -var _a = pick(['b'], { a: 'a', b: 'b' }); // T: "b" | "a" ??? (before fix) diff --git a/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.js b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.js new file mode 100644 index 0000000000000..a957e636a0edf --- /dev/null +++ b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.js @@ -0,0 +1,11 @@ +//// [tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening1.ts] //// + +//// [bindingPatternContextualTypeDoesNotCauseWidening1.ts] +declare function pick(keys: T[], obj?: O): Pick; +const _ = pick(['b'], { a: 'a', b: 'b' }); // T: "b" +const { } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" + + +//// [bindingPatternContextualTypeDoesNotCauseWidening1.js] +var _ = pick(['b'], { a: 'a', b: 'b' }); // T: "b" +var _a = pick(['b'], { a: 'a', b: 'b' }); // T: "b" diff --git a/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.symbols b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.symbols similarity index 72% rename from tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.symbols rename to tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.symbols index b19da02779efb..71ad2c5a7c376 100644 --- a/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.symbols +++ b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.symbols @@ -1,27 +1,27 @@ -//// [tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening.ts] //// +//// [tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening1.ts] //// -=== bindingPatternContextualTypeDoesNotCauseWidening.ts === +=== bindingPatternContextualTypeDoesNotCauseWidening1.ts === declare function pick(keys: T[], obj?: O): Pick; ->pick : Symbol(pick, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 0)) ->O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 22)) ->T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 24)) ->O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 22)) ->keys : Symbol(keys, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 44)) ->T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 24)) ->obj : Symbol(obj, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 54)) ->O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 22)) +>pick : Symbol(pick, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 0)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 22)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 24)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 22)) +>keys : Symbol(keys, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 44)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 24)) +>obj : Symbol(obj, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 54)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 22)) >Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) ->O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 22)) ->T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 24)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 22)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 24)) const _ = pick(['b'], { a: 'a', b: 'b' }); // T: "b" ->_ : Symbol(_, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 1, 5)) ->pick : Symbol(pick, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 0)) ->a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 1, 26)) ->b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 1, 34)) +>_ : Symbol(_, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 1, 5)) +>pick : Symbol(pick, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 0)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 1, 26)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 1, 34)) -const { } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" | "a" ??? (before fix) ->pick : Symbol(pick, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 0, 0)) ->a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 2, 26)) ->b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening.ts, 2, 34)) +const { } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" +>pick : Symbol(pick, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 0, 0)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 2, 26)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening1.ts, 2, 34)) diff --git a/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.types b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.types similarity index 81% rename from tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.types rename to tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.types index d70d2910442b1..5848df5fea236 100644 --- a/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening.types +++ b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening1.types @@ -1,6 +1,6 @@ -//// [tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening.ts] //// +//// [tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening1.ts] //// -=== bindingPatternContextualTypeDoesNotCauseWidening.ts === +=== bindingPatternContextualTypeDoesNotCauseWidening1.ts === declare function pick(keys: T[], obj?: O): Pick; >pick : (keys: T[], obj?: O) => Pick >keys : T[] @@ -18,7 +18,7 @@ const _ = pick(['b'], { a: 'a', b: 'b' }); // T: "b" >b : string >'b' : "b" -const { } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" | "a" ??? (before fix) +const { } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" >pick(['b'], { a: 'a', b: 'b' }) : Pick<{ a: string; b: string; }, "b"> >pick : (keys: T[], obj?: O) => Pick >['b'] : "b"[] diff --git a/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening2.symbols b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening2.symbols new file mode 100644 index 0000000000000..6f112062f1c92 --- /dev/null +++ b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening2.symbols @@ -0,0 +1,164 @@ +//// [tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening2.ts] //// + +=== bindingPatternContextualTypeDoesNotCauseWidening2.ts === +// https://github.com/microsoft/TypeScript/issues/56771 + +declare function fn1(t: T): T; +>fn1 : Symbol(fn1, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 0, 0)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 2, 21)) +>A : Symbol(A, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 2, 32)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 2, 37)) +>t : Symbol(t, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 2, 70)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 2, 21)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 2, 21)) + +const { A } = fn1({ A: { a: "A" } }); +>A : Symbol(A, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 3, 7)) +>fn1 : Symbol(fn1, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 0, 0)) +>A : Symbol(A, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 3, 19)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 3, 24)) + +A.a; +>A.a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 3, 24)) +>A : Symbol(A, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 3, 7)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 3, 24)) + +declare function fn2(t: T): T; +>fn2 : Symbol(fn2, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 4, 4)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 6, 21)) +>A : Symbol(A, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 6, 32)) +>t : Symbol(t, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 6, 51)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 6, 21)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 6, 21)) + +const { A: [nested] } = fn2({ A: ["a"] }); +>A : Symbol(A, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 7, 29)) +>nested : Symbol(nested, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 7, 12)) +>fn2 : Symbol(fn2, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 4, 4)) +>A : Symbol(A, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 7, 29)) + +declare function fn3(obj: T): T; +>fn3 : Symbol(fn3, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 7, 42)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 9, 21)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 9, 32)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 9, 44)) +>obj : Symbol(obj, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 9, 59)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 9, 21)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 9, 21)) + +const { a: [a3] } = fn3({ a: [1, ""], b: "" }); +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 10, 25)) +>a3 : Symbol(a3, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 10, 12)) +>fn3 : Symbol(fn3, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 7, 42)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 10, 25)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 10, 37)) + +declare function fn4(obj: T): T; +>fn4 : Symbol(fn4, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 10, 47)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 12, 21)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 12, 32)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 12, 44)) +>obj : Symbol(obj, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 12, 61)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 12, 21)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 12, 21)) + +const [{ a: a4 }] = fn4([{ a: "", b: 10 }, { a: true, b: "" }]); +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 13, 26)) +>a4 : Symbol(a4, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 13, 8)) +>fn4 : Symbol(fn4, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 10, 47)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 13, 26)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 13, 33)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 13, 44)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 13, 53)) + +declare function fn5< +>fn5 : Symbol(fn5, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 13, 64)) + + O extends { a?: "a"; b?: "b1" | "b2"; c?: "c" }[], +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 15, 21)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 16, 13)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 16, 22)) +>c : Symbol(c, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 16, 39)) + + T extends keyof O[number], +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 16, 52)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 15, 21)) + +>( + keys: T[], +>keys : Symbol(keys, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 18, 2)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 16, 52)) + + obj?: O, +>obj : Symbol(obj, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 19, 12)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 15, 21)) + +): { + [K in keyof O]: Pick; +>K : Symbol(K, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 22, 3)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 15, 21)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 15, 21)) +>K : Symbol(K, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 22, 3)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 16, 52)) +} +const [{ b: b5_1 }, { b: b5_2 }] = fn5(["b"], [{ a: "a", b: "b1" }, { b: "b2", c: "c" }]); +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 56)) +>b5_1 : Symbol(b5_1, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 8)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 69)) +>b5_2 : Symbol(b5_2, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 21)) +>fn5 : Symbol(fn5, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 13, 64)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 48)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 56)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 69)) +>c : Symbol(c, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 78)) + +declare function fn6< +>fn6 : Symbol(fn6, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 90)) + + O extends { a?: "valA", b?: "valB" | "valC" } | null, +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 26, 21)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 27, 13)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 27, 25)) + + T extends keyof O +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 27, 55)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 26, 21)) + +>( + keys: T[], +>keys : Symbol(keys, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 29, 2)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 27, 55)) + + obj?: O, +>obj : Symbol(obj, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 30, 12)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 26, 21)) + +): Pick & { pickedKeys: T }; +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>O : Symbol(O, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 26, 21)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 27, 55)) +>pickedKeys : Symbol(pickedKeys, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 32, 17)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 27, 55)) + +const { b: b6, pickedKeys } = fn6(["b"], { a: "valA", b: "valB" }); +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 33, 53)) +>b6 : Symbol(b6, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 33, 7)) +>pickedKeys : Symbol(pickedKeys, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 33, 14)) +>fn6 : Symbol(fn6, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 24, 90)) +>a : Symbol(a, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 33, 42)) +>b : Symbol(b, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 33, 53)) + +declare function fn7(obj: T): T +>fn7 : Symbol(fn7, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 33, 67)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 35, 21)) +>k : Symbol(k, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 35, 34)) +>obj : Symbol(obj, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 35, 59)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 35, 21)) +>T : Symbol(T, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 35, 21)) + +const { a7 } = fn7({ a7: 'a' }) +>a7 : Symbol(a7, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 36, 7)) +>fn7 : Symbol(fn7, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 33, 67)) +>a7 : Symbol(a7, Decl(bindingPatternContextualTypeDoesNotCauseWidening2.ts, 36, 20)) + diff --git a/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening2.types b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening2.types new file mode 100644 index 0000000000000..ebac97601bf89 --- /dev/null +++ b/tests/baselines/reference/bindingPatternContextualTypeDoesNotCauseWidening2.types @@ -0,0 +1,168 @@ +//// [tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening2.ts] //// + +=== bindingPatternContextualTypeDoesNotCauseWidening2.ts === +// https://github.com/microsoft/TypeScript/issues/56771 + +declare function fn1(t: T): T; +>fn1 : (t: T) => T +>A : { a: "A"; } | null | undefined +>a : "A" +>t : T + +const { A } = fn1({ A: { a: "A" } }); +>A : { a: "A"; } +>fn1({ A: { a: "A" } }) : { A: { a: "A"; }; } +>fn1 : (t: T) => T +>{ A: { a: "A" } } : { A: { a: "A"; }; } +>A : { a: "A"; } +>{ a: "A" } : { a: "A"; } +>a : "A" +>"A" : "A" + +A.a; +>A.a : "A" +>A : { a: "A"; } +>a : "A" + +declare function fn2(t: T): T; +>fn2 : (t: T) => T +>A : ["a" | "b"] +>t : T + +const { A: [nested] } = fn2({ A: ["a"] }); +>A : any +>nested : "a" +>fn2({ A: ["a"] }) : { A: ["a"]; } +>fn2 : (t: T) => T +>{ A: ["a"] } : { A: ["a"]; } +>A : ["a"] +>["a"] : ["a"] +>"a" : "a" + +declare function fn3(obj: T): T; +>fn3 : (obj: T) => T +>a : unknown +>b : unknown +>obj : T + +const { a: [a3] } = fn3({ a: [1, ""], b: "" }); +>a : any +>a3 : number +>fn3({ a: [1, ""], b: "" }) : { a: [number, string]; b: string; } +>fn3 : (obj: T) => T +>{ a: [1, ""], b: "" } : { a: [number, string]; b: string; } +>a : [number, string] +>[1, ""] : [number, string] +>1 : 1 +>"" : "" +>b : string +>"" : "" + +declare function fn4(obj: T): T; +>fn4 : (obj: T) => T +>a : unknown +>b : unknown +>obj : T + +const [{ a: a4 }] = fn4([{ a: "", b: 10 }, { a: true, b: "" }]); +>a : any +>a4 : string +>fn4([{ a: "", b: 10 }, { a: true, b: "" }]) : [{ a: string; b: number; }, { a: boolean; b: string; }] +>fn4 : (obj: T) => T +>[{ a: "", b: 10 }, { a: true, b: "" }] : [{ a: string; b: number; }, { a: true; b: string; }] +>{ a: "", b: 10 } : { a: string; b: number; } +>a : string +>"" : "" +>b : number +>10 : 10 +>{ a: true, b: "" } : { a: true; b: string; } +>a : true +>true : true +>b : string +>"" : "" + +declare function fn5< +>fn5 : (keys: T[], obj?: O) => { [K in keyof O]: Pick; } + + O extends { a?: "a"; b?: "b1" | "b2"; c?: "c" }[], +>a : "a" | undefined +>b : "b1" | "b2" | undefined +>c : "c" | undefined + + T extends keyof O[number], +>( + keys: T[], +>keys : T[] + + obj?: O, +>obj : O | undefined + +): { + [K in keyof O]: Pick; +} +const [{ b: b5_1 }, { b: b5_2 }] = fn5(["b"], [{ a: "a", b: "b1" }, { b: "b2", c: "c" }]); +>b : any +>b5_1 : "b1" +>b : any +>b5_2 : "b2" +>fn5(["b"], [{ a: "a", b: "b1" }, { b: "b2", c: "c" }]) : [Pick<{ a: "a"; b: "b1"; }, "b">, Pick<{ b: "b2"; c: "c"; }, "b">] +>fn5 : (keys: T[], obj?: O | undefined) => { [K in keyof O]: Pick; } +>["b"] : "b"[] +>"b" : "b" +>[{ a: "a", b: "b1" }, { b: "b2", c: "c" }] : [{ a: "a"; b: "b1"; }, { b: "b2"; c: "c"; }] +>{ a: "a", b: "b1" } : { a: "a"; b: "b1"; } +>a : "a" +>"a" : "a" +>b : "b1" +>"b1" : "b1" +>{ b: "b2", c: "c" } : { b: "b2"; c: "c"; } +>b : "b2" +>"b2" : "b2" +>c : "c" +>"c" : "c" + +declare function fn6< +>fn6 : (keys: T[], obj?: O) => Pick & { pickedKeys: T;} + + O extends { a?: "valA", b?: "valB" | "valC" } | null, +>a : "valA" | undefined +>b : "valB" | "valC" | undefined + + T extends keyof O +>( + keys: T[], +>keys : T[] + + obj?: O, +>obj : O | undefined + +): Pick & { pickedKeys: T }; +>pickedKeys : T + +const { b: b6, pickedKeys } = fn6(["b"], { a: "valA", b: "valB" }); +>b : any +>b6 : "valB" +>pickedKeys : "b" +>fn6(["b"], { a: "valA", b: "valB" }) : Pick<{ a: "valA"; b: "valB"; }, "b"> & { pickedKeys: "b"; } +>fn6 : (keys: T[], obj?: O | undefined) => Pick & { pickedKeys: T; } +>["b"] : "b"[] +>"b" : "b" +>{ a: "valA", b: "valB" } : { a: "valA"; b: "valB"; } +>a : "valA" +>"valA" : "valA" +>b : "valB" +>"valB" : "valB" + +declare function fn7(obj: T): T +>fn7 : (obj: T) => T +>k : string +>obj : T + +const { a7 } = fn7({ a7: 'a' }) +>a7 : "a" +>fn7({ a7: 'a' }) : { a7: "a"; } +>fn7 : (obj: T) => T +>{ a7: 'a' } : { a7: "a"; } +>a7 : "a" +>'a' : "a" + diff --git a/tests/baselines/reference/checkDestructuringShorthandAssigment2.errors.txt b/tests/baselines/reference/checkDestructuringShorthandAssigment2.errors.txt index 42032f9db1bb1..71c4cc39cc486 100644 --- a/tests/baselines/reference/checkDestructuringShorthandAssigment2.errors.txt +++ b/tests/baselines/reference/checkDestructuringShorthandAssigment2.errors.txt @@ -1,5 +1,5 @@ checkDestructuringShorthandAssigment2.ts(4,7): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -checkDestructuringShorthandAssigment2.ts(4,27): error TS2353: Object literal may only specify known properties, and '[k]' does not exist in type '{ x: any; }'. +checkDestructuringShorthandAssigment2.ts(4,27): error TS2353: Object literal may only specify known properties, and '[k]' does not exist in type '{ x: unknown; }'. ==== checkDestructuringShorthandAssigment2.ts (2 errors) ==== @@ -10,5 +10,5 @@ checkDestructuringShorthandAssigment2.ts(4,27): error TS2353: Object literal may ~ !!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value. ~~~ -!!! error TS2353: Object literal may only specify known properties, and '[k]' does not exist in type '{ x: any; }'. +!!! error TS2353: Object literal may only specify known properties, and '[k]' does not exist in type '{ x: unknown; }'. \ No newline at end of file diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt index 0a47f24e6e3a8..d6f10f9f7dc1d 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.errors.txt @@ -1,24 +1,24 @@ -declarationEmitDestructuringObjectLiteralPattern.ts(2,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. -declarationEmitDestructuringObjectLiteralPattern.ts(3,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. -declarationEmitDestructuringObjectLiteralPattern.ts(5,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. -declarationEmitDestructuringObjectLiteralPattern.ts(6,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. +declarationEmitDestructuringObjectLiteralPattern.ts(2,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: unknown; }'. +declarationEmitDestructuringObjectLiteralPattern.ts(3,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: unknown; }'. +declarationEmitDestructuringObjectLiteralPattern.ts(5,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: unknown; }'. +declarationEmitDestructuringObjectLiteralPattern.ts(6,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: unknown; }'. ==== declarationEmitDestructuringObjectLiteralPattern.ts (4 errors) ==== var { } = { x: 5, y: "hello" }; var { x4 } = { x4: 5, y4: "hello" }; ~~ -!!! error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: unknown; }'. var { y5 } = { x5: 5, y5: "hello" }; ~~ -!!! error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: unknown; }'. var { x6, y6 } = { x6: 5, y6: "hello" }; var { x7: a1 } = { x7: 5, y7: "hello" }; ~~ -!!! error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: unknown; }'. var { y8: b1 } = { x8: 5, y8: "hello" }; ~~ -!!! error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: unknown; }'. var { x9: a2, y9: b2 } = { x9: 5, y9: "hello" }; var { a: x11, b: { a: y11, b: { a: z11 }}} = { a: 1, b: { a: "hello", b: { a: true } } }; diff --git a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt index ac14a9de55797..de4e68644a41f 100644 --- a/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt +++ b/tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.errors.txt @@ -1,22 +1,22 @@ -declarationEmitDestructuringObjectLiteralPattern1.ts(2,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. -declarationEmitDestructuringObjectLiteralPattern1.ts(3,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. -declarationEmitDestructuringObjectLiteralPattern1.ts(5,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. -declarationEmitDestructuringObjectLiteralPattern1.ts(6,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. +declarationEmitDestructuringObjectLiteralPattern1.ts(2,23): error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: unknown; }'. +declarationEmitDestructuringObjectLiteralPattern1.ts(3,16): error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: unknown; }'. +declarationEmitDestructuringObjectLiteralPattern1.ts(5,27): error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: unknown; }'. +declarationEmitDestructuringObjectLiteralPattern1.ts(6,20): error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: unknown; }'. ==== declarationEmitDestructuringObjectLiteralPattern1.ts (4 errors) ==== var { } = { x: 5, y: "hello" }; var { x4 } = { x4: 5, y4: "hello" }; ~~ -!!! error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'y4' does not exist in type '{ x4: unknown; }'. var { y5 } = { x5: 5, y5: "hello" }; ~~ -!!! error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'x5' does not exist in type '{ y5: unknown; }'. var { x6, y6 } = { x6: 5, y6: "hello" }; var { x7: a1 } = { x7: 5, y7: "hello" }; ~~ -!!! error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'y7' does not exist in type '{ x7: unknown; }'. var { y8: b1 } = { x8: 5, y8: "hello" }; ~~ -!!! error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'x8' does not exist in type '{ y8: unknown; }'. var { x9: a2, y9: b2 } = { x9: 5, y9: "hello" }; \ No newline at end of file diff --git a/tests/baselines/reference/declarationsAndAssignments.errors.txt b/tests/baselines/reference/declarationsAndAssignments.errors.txt index 332a127335f04..72073f141cf4a 100644 --- a/tests/baselines/reference/declarationsAndAssignments.errors.txt +++ b/tests/baselines/reference/declarationsAndAssignments.errors.txt @@ -1,8 +1,8 @@ declarationsAndAssignments.ts(5,16): error TS2493: Tuple type '[number, string]' of length '2' has no element at index '2'. -declarationsAndAssignments.ts(23,25): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: any; }'. -declarationsAndAssignments.ts(24,19): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: any; }'. -declarationsAndAssignments.ts(28,28): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: any; }'. -declarationsAndAssignments.ts(29,22): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: any; }'. +declarationsAndAssignments.ts(23,25): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: unknown; }'. +declarationsAndAssignments.ts(24,19): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: unknown; }'. +declarationsAndAssignments.ts(28,28): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: unknown; }'. +declarationsAndAssignments.ts(29,22): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: unknown; }'. declarationsAndAssignments.ts(58,9): error TS2403: Subsequent variable declarations must have the same type. Variable 'y' must be of type 'string | number', but here has type 'string'. declarationsAndAssignments.ts(62,10): error TS2493: Tuple type '[]' of length '0' has no element at index '0'. declarationsAndAssignments.ts(62,13): error TS2493: Tuple type '[]' of length '0' has no element at index '1'. @@ -47,19 +47,19 @@ declarationsAndAssignments.ts(138,9): error TS2322: Type 'number' is not assigna var { } = { x: 5, y: "hello" }; // Ok, empty binding pattern means nothing var { x } = { x: 5, y: "hello" }; // Error, no y in target ~ -!!! error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: unknown; }'. var { y } = { x: 5, y: "hello" }; // Error, no x in target ~ -!!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: unknown; }'. var { x, y } = { x: 5, y: "hello" }; var x: number; var y: string; var { x: a } = { x: 5, y: "hello" }; // Error, no y in target ~ -!!! error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: unknown; }'. var { y: b } = { x: 5, y: "hello" }; // Error, no x in target ~ -!!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: unknown; }'. var { x: a, y: b } = { x: 5, y: "hello" }; var a: number; var b: string; diff --git a/tests/baselines/reference/declarationsAndAssignments.types b/tests/baselines/reference/declarationsAndAssignments.types index f393dfbb29d9d..ce29665740a99 100644 --- a/tests/baselines/reference/declarationsAndAssignments.types +++ b/tests/baselines/reference/declarationsAndAssignments.types @@ -299,13 +299,13 @@ function f10() { >f10 : () => void var { a, b } = {}; // Error ->a : any ->b : any ->{} : { a: any; b: any; } +>a : unknown +>b : unknown +>{} : { a: unknown; b: unknown; } var { a, b } = []; // Error ->a : any ->b : any +>a : unknown +>b : unknown >[] : undefined[] } diff --git a/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.errors.txt b/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.errors.txt index a0907af1dce40..9fddbe26c6fec 100644 --- a/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.errors.txt +++ b/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.errors.txt @@ -1,5 +1,5 @@ destructuredLateBoundNameHasCorrectTypes.ts(11,21): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -destructuredLateBoundNameHasCorrectTypes.ts(11,37): error TS2353: Object literal may only specify known properties, and 'prop' does not exist in type '{ prop2: any; }'. +destructuredLateBoundNameHasCorrectTypes.ts(11,37): error TS2353: Object literal may only specify known properties, and 'prop' does not exist in type '{ prop2: unknown; }'. ==== destructuredLateBoundNameHasCorrectTypes.ts (2 errors) ==== @@ -17,5 +17,5 @@ destructuredLateBoundNameHasCorrectTypes.ts(11,37): error TS2353: Object literal ~~~~~~~~~ !!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value. ~~~~ -!!! error TS2353: Object literal may only specify known properties, and 'prop' does not exist in type '{ prop2: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'prop' does not exist in type '{ prop2: unknown; }'. \ No newline at end of file diff --git a/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types b/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types index 35f40b8548fbc..4a3daf1b601ac 100644 --- a/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types +++ b/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types @@ -33,8 +33,8 @@ const notPresent = "prop2"; let { [notPresent]: computed2 } = { prop: "b" }; >notPresent : "prop2" ->computed2 : any ->{ prop: "b" } : { prop: string; prop2: any; } +>computed2 : unknown +>{ prop: "b" } : { prop: string; prop2: unknown; } >prop : string >"b" : "b" diff --git a/tests/baselines/reference/destructuringFromUnionSpread.types b/tests/baselines/reference/destructuringFromUnionSpread.types index 37085593f7ab0..3aaabf02f004c 100644 --- a/tests/baselines/reference/destructuringFromUnionSpread.types +++ b/tests/baselines/reference/destructuringFromUnionSpread.types @@ -11,7 +11,7 @@ declare const x: A | B; >x : A | B const { a } = { ...x } // error ->a : any ->{ ...x } : { a: any; } | { a: any; b: number; } +>a : unknown +>{ ...x } : { a: unknown; } | { a: unknown; b: number; } >x : A | B diff --git a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.errors.txt b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.errors.txt index 822cb4d6c512d..49b2c99babe75 100644 --- a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.errors.txt +++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.errors.txt @@ -3,7 +3,7 @@ destructuringObjectBindingPatternAndAssignment3.ts(3,5): error TS2322: Type '{ i destructuringObjectBindingPatternAndAssignment3.ts(3,6): error TS2339: Property 'i' does not exist on type 'string | number'. destructuringObjectBindingPatternAndAssignment3.ts(4,6): error TS2339: Property 'i1' does not exist on type 'string | number | {}'. destructuringObjectBindingPatternAndAssignment3.ts(5,12): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -destructuringObjectBindingPatternAndAssignment3.ts(5,21): error TS2353: Object literal may only specify known properties, and 'f212' does not exist in type '{ f21: any; }'. +destructuringObjectBindingPatternAndAssignment3.ts(5,21): error TS2353: Object literal may only specify known properties, and 'f212' does not exist in type '{ f21: unknown; }'. destructuringObjectBindingPatternAndAssignment3.ts(6,7): error TS1005: ':' expected. destructuringObjectBindingPatternAndAssignment3.ts(6,15): error TS1005: ':' expected. destructuringObjectBindingPatternAndAssignment3.ts(7,12): error TS1005: ':' expected. @@ -26,7 +26,7 @@ destructuringObjectBindingPatternAndAssignment3.ts(7,12): error TS1005: ':' expe ~~~ !!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value. ~~~~ -!!! error TS2353: Object literal may only specify known properties, and 'f212' does not exist in type '{ f21: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'f212' does not exist in type '{ f21: unknown; }'. var {1} = { 1 }; ~ !!! error TS1005: ':' expected. diff --git a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.types b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.types index 8cfafa50edb5e..0185bb51829e6 100644 --- a/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.types +++ b/tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.types @@ -23,7 +23,7 @@ var {i1}: string | number| {} = { i1: 2 }; var { f2: {f21} = { f212: "string" } }: any = undefined; >f2 : any >f21 : any ->{ f212: "string" } : { f212: string; f21: any; } +>{ f212: "string" } : { f212: string; f21: unknown; } >f212 : string >"string" : "string" >undefined : undefined diff --git a/tests/baselines/reference/destructuringSpread.types b/tests/baselines/reference/destructuringSpread.types index 38f78dd8cfd59..4ac0a97eaf905 100644 --- a/tests/baselines/reference/destructuringSpread.types +++ b/tests/baselines/reference/destructuringSpread.types @@ -51,8 +51,8 @@ const { c, d, e, f, g } = { >d : number >e : number >f : number ->g : any ->{ ...{ ...{ ...{ c: 0, }, d: 0 }, e: 0 }, f: 0} : { f: number; g: any; e: number; d: number; c: number; } +>g : unknown +>{ ...{ ...{ ...{ c: 0, }, d: 0 }, e: 0 }, f: 0} : { f: number; g: unknown; e: number; d: number; c: number; } ...{ >{ ...{ ...{ c: 0, }, d: 0 }, e: 0 } : { e: number; d: number; c: number; } diff --git a/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).js b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).js new file mode 100644 index 0000000000000..3a06297486f11 --- /dev/null +++ b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).js @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/inferTupleFromBindingPattern.ts] //// + +//// [inferTupleFromBindingPattern.ts] +declare function f(cb: () => T): T; +const [e1, e2, e3] = f(() => [1, "hi", true]); + +// repro from #42969 +declare const f2: (t: T) => [T, string[]]; +const [[f2e1]] = f2(['1']); +f2e1.toLowerCase(); + +declare const f3: (t: T) => [[T, string[]]]; +const [[[f3e1]]] = f3(['1']); +f3e1.toLowerCase(); + +declare const f4: (t: T) => [T, number, string[]]; +const [[f4e1], ...f4rest1] = f4(['1']); +f4e1.toLowerCase(); + +declare const f5: (t: T) => [[T, number, string[]]]; +const [[[f5e1], ...f5rest1]] = f5(['1']); +f5e1.toLowerCase(); + +declare const f6: (t: T) => [...T, number]; +const [f6e1] = f6(['1']); +f6e1.toLowerCase(); + +declare const f7: (t: T) => [number, ...T]; +const [_, f7e1] = f7(['1']); +f7e1.toLowerCase(); + + +//// [inferTupleFromBindingPattern.js] +"use strict"; +var _a = f(function () { return [1, "hi", true]; }), e1 = _a[0], e2 = _a[1], e3 = _a[2]; +var f2e1 = f2(['1'])[0][0]; +f2e1.toLowerCase(); +var f3e1 = f3(['1'])[0][0][0]; +f3e1.toLowerCase(); +var _b = f4(['1']), f4e1 = _b[0][0], f4rest1 = _b.slice(1); +f4e1.toLowerCase(); +var _c = f5(['1'])[0], f5e1 = _c[0][0], f5rest1 = _c.slice(1); +f5e1.toLowerCase(); +var f6e1 = f6(['1'])[0]; +f6e1.toLowerCase(); +var _d = f7(['1']), _ = _d[0], f7e1 = _d[1]; +f7e1.toLowerCase(); diff --git a/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).symbols b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).symbols new file mode 100644 index 0000000000000..332bcbc0c1145 --- /dev/null +++ b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).symbols @@ -0,0 +1,116 @@ +//// [tests/cases/compiler/inferTupleFromBindingPattern.ts] //// + +=== inferTupleFromBindingPattern.ts === +declare function f(cb: () => T): T; +>f : Symbol(f, Decl(inferTupleFromBindingPattern.ts, 0, 0)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19)) +>cb : Symbol(cb, Decl(inferTupleFromBindingPattern.ts, 0, 22)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19)) + +const [e1, e2, e3] = f(() => [1, "hi", true]); +>e1 : Symbol(e1, Decl(inferTupleFromBindingPattern.ts, 1, 7)) +>e2 : Symbol(e2, Decl(inferTupleFromBindingPattern.ts, 1, 10)) +>e3 : Symbol(e3, Decl(inferTupleFromBindingPattern.ts, 1, 14)) +>f : Symbol(f, Decl(inferTupleFromBindingPattern.ts, 0, 0)) + +// repro from #42969 +declare const f2: (t: T) => [T, string[]]; +>f2 : Symbol(f2, Decl(inferTupleFromBindingPattern.ts, 4, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 4, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 4, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 4, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 4, 19)) + +const [[f2e1]] = f2(['1']); +>f2e1 : Symbol(f2e1, Decl(inferTupleFromBindingPattern.ts, 5, 8)) +>f2 : Symbol(f2, Decl(inferTupleFromBindingPattern.ts, 4, 13)) + +f2e1.toLowerCase(); +>f2e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f2e1 : Symbol(f2e1, Decl(inferTupleFromBindingPattern.ts, 5, 8)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f3: (t: T) => [[T, string[]]]; +>f3 : Symbol(f3, Decl(inferTupleFromBindingPattern.ts, 8, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 8, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 8, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 8, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 8, 19)) + +const [[[f3e1]]] = f3(['1']); +>f3e1 : Symbol(f3e1, Decl(inferTupleFromBindingPattern.ts, 9, 9)) +>f3 : Symbol(f3, Decl(inferTupleFromBindingPattern.ts, 8, 13)) + +f3e1.toLowerCase(); +>f3e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f3e1 : Symbol(f3e1, Decl(inferTupleFromBindingPattern.ts, 9, 9)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f4: (t: T) => [T, number, string[]]; +>f4 : Symbol(f4, Decl(inferTupleFromBindingPattern.ts, 12, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 12, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 12, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 12, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 12, 19)) + +const [[f4e1], ...f4rest1] = f4(['1']); +>f4e1 : Symbol(f4e1, Decl(inferTupleFromBindingPattern.ts, 13, 8)) +>f4rest1 : Symbol(f4rest1, Decl(inferTupleFromBindingPattern.ts, 13, 14)) +>f4 : Symbol(f4, Decl(inferTupleFromBindingPattern.ts, 12, 13)) + +f4e1.toLowerCase(); +>f4e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f4e1 : Symbol(f4e1, Decl(inferTupleFromBindingPattern.ts, 13, 8)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f5: (t: T) => [[T, number, string[]]]; +>f5 : Symbol(f5, Decl(inferTupleFromBindingPattern.ts, 16, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 16, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 16, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 16, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 16, 19)) + +const [[[f5e1], ...f5rest1]] = f5(['1']); +>f5e1 : Symbol(f5e1, Decl(inferTupleFromBindingPattern.ts, 17, 9)) +>f5rest1 : Symbol(f5rest1, Decl(inferTupleFromBindingPattern.ts, 17, 15)) +>f5 : Symbol(f5, Decl(inferTupleFromBindingPattern.ts, 16, 13)) + +f5e1.toLowerCase(); +>f5e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f5e1 : Symbol(f5e1, Decl(inferTupleFromBindingPattern.ts, 17, 9)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f6: (t: T) => [...T, number]; +>f6 : Symbol(f6, Decl(inferTupleFromBindingPattern.ts, 20, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 20, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 20, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 20, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 20, 19)) + +const [f6e1] = f6(['1']); +>f6e1 : Symbol(f6e1, Decl(inferTupleFromBindingPattern.ts, 21, 7)) +>f6 : Symbol(f6, Decl(inferTupleFromBindingPattern.ts, 20, 13)) + +f6e1.toLowerCase(); +>f6e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f6e1 : Symbol(f6e1, Decl(inferTupleFromBindingPattern.ts, 21, 7)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f7: (t: T) => [number, ...T]; +>f7 : Symbol(f7, Decl(inferTupleFromBindingPattern.ts, 24, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 24, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 24, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 24, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 24, 19)) + +const [_, f7e1] = f7(['1']); +>_ : Symbol(_, Decl(inferTupleFromBindingPattern.ts, 25, 7)) +>f7e1 : Symbol(f7e1, Decl(inferTupleFromBindingPattern.ts, 25, 9)) +>f7 : Symbol(f7, Decl(inferTupleFromBindingPattern.ts, 24, 13)) + +f7e1.toLowerCase(); +>f7e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f7e1 : Symbol(f7e1, Decl(inferTupleFromBindingPattern.ts, 25, 9)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + diff --git a/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).types b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).types new file mode 100644 index 0000000000000..1f9b2deed7630 --- /dev/null +++ b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=false).types @@ -0,0 +1,125 @@ +//// [tests/cases/compiler/inferTupleFromBindingPattern.ts] //// + +=== inferTupleFromBindingPattern.ts === +declare function f(cb: () => T): T; +>f : (cb: () => T) => T +>cb : () => T + +const [e1, e2, e3] = f(() => [1, "hi", true]); +>e1 : number +>e2 : string +>e3 : boolean +>f(() => [1, "hi", true]) : [number, string, boolean] +>f : (cb: () => T) => T +>() => [1, "hi", true] : () => [number, string, boolean] +>[1, "hi", true] : [number, string, true] +>1 : 1 +>"hi" : "hi" +>true : true + +// repro from #42969 +declare const f2: (t: T) => [T, string[]]; +>f2 : (t: T) => [T, string[]] +>t : T + +const [[f2e1]] = f2(['1']); +>f2e1 : string +>f2(['1']) : [[string], string[]] +>f2 : (t: T) => [T, string[]] +>['1'] : [string] +>'1' : "1" + +f2e1.toLowerCase(); +>f2e1.toLowerCase() : string +>f2e1.toLowerCase : () => string +>f2e1 : string +>toLowerCase : () => string + +declare const f3: (t: T) => [[T, string[]]]; +>f3 : (t: T) => [[T, string[]]] +>t : T + +const [[[f3e1]]] = f3(['1']); +>f3e1 : string +>f3(['1']) : [[[string], string[]]] +>f3 : (t: T) => [[T, string[]]] +>['1'] : [string] +>'1' : "1" + +f3e1.toLowerCase(); +>f3e1.toLowerCase() : string +>f3e1.toLowerCase : () => string +>f3e1 : string +>toLowerCase : () => string + +declare const f4: (t: T) => [T, number, string[]]; +>f4 : (t: T) => [T, number, string[]] +>t : T + +const [[f4e1], ...f4rest1] = f4(['1']); +>f4e1 : string +>f4rest1 : [number, string[]] +>f4(['1']) : [[string], number, string[]] +>f4 : (t: T) => [T, number, string[]] +>['1'] : [string] +>'1' : "1" + +f4e1.toLowerCase(); +>f4e1.toLowerCase() : string +>f4e1.toLowerCase : () => string +>f4e1 : string +>toLowerCase : () => string + +declare const f5: (t: T) => [[T, number, string[]]]; +>f5 : (t: T) => [[T, number, string[]]] +>t : T + +const [[[f5e1], ...f5rest1]] = f5(['1']); +>f5e1 : string +>f5rest1 : [number, string[]] +>f5(['1']) : [[[string], number, string[]]] +>f5 : (t: T) => [[T, number, string[]]] +>['1'] : [string] +>'1' : "1" + +f5e1.toLowerCase(); +>f5e1.toLowerCase() : string +>f5e1.toLowerCase : () => string +>f5e1 : string +>toLowerCase : () => string + +declare const f6: (t: T) => [...T, number]; +>f6 : (t: T) => [...T, number] +>t : T + +const [f6e1] = f6(['1']); +>f6e1 : string +>f6(['1']) : [string, number] +>f6 : (t: T) => [...T, number] +>['1'] : [string] +>'1' : "1" + +f6e1.toLowerCase(); +>f6e1.toLowerCase() : string +>f6e1.toLowerCase : () => string +>f6e1 : string +>toLowerCase : () => string + +declare const f7: (t: T) => [number, ...T]; +>f7 : (t: T) => [number, ...T] +>t : T + +const [_, f7e1] = f7(['1']); +>_ : number +>f7e1 : string +>f7(['1']) : [number, string] +>f7 : (t: T) => [number, ...T] +>['1'] : [string] +>'1' : "1" + +f7e1.toLowerCase(); +>f7e1.toLowerCase() : string +>f7e1.toLowerCase : () => string +>f7e1 : string +>toLowerCase : () => string + diff --git a/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).js b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).js new file mode 100644 index 0000000000000..3a06297486f11 --- /dev/null +++ b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).js @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/inferTupleFromBindingPattern.ts] //// + +//// [inferTupleFromBindingPattern.ts] +declare function f(cb: () => T): T; +const [e1, e2, e3] = f(() => [1, "hi", true]); + +// repro from #42969 +declare const f2: (t: T) => [T, string[]]; +const [[f2e1]] = f2(['1']); +f2e1.toLowerCase(); + +declare const f3: (t: T) => [[T, string[]]]; +const [[[f3e1]]] = f3(['1']); +f3e1.toLowerCase(); + +declare const f4: (t: T) => [T, number, string[]]; +const [[f4e1], ...f4rest1] = f4(['1']); +f4e1.toLowerCase(); + +declare const f5: (t: T) => [[T, number, string[]]]; +const [[[f5e1], ...f5rest1]] = f5(['1']); +f5e1.toLowerCase(); + +declare const f6: (t: T) => [...T, number]; +const [f6e1] = f6(['1']); +f6e1.toLowerCase(); + +declare const f7: (t: T) => [number, ...T]; +const [_, f7e1] = f7(['1']); +f7e1.toLowerCase(); + + +//// [inferTupleFromBindingPattern.js] +"use strict"; +var _a = f(function () { return [1, "hi", true]; }), e1 = _a[0], e2 = _a[1], e3 = _a[2]; +var f2e1 = f2(['1'])[0][0]; +f2e1.toLowerCase(); +var f3e1 = f3(['1'])[0][0][0]; +f3e1.toLowerCase(); +var _b = f4(['1']), f4e1 = _b[0][0], f4rest1 = _b.slice(1); +f4e1.toLowerCase(); +var _c = f5(['1'])[0], f5e1 = _c[0][0], f5rest1 = _c.slice(1); +f5e1.toLowerCase(); +var f6e1 = f6(['1'])[0]; +f6e1.toLowerCase(); +var _d = f7(['1']), _ = _d[0], f7e1 = _d[1]; +f7e1.toLowerCase(); diff --git a/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).symbols b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).symbols new file mode 100644 index 0000000000000..332bcbc0c1145 --- /dev/null +++ b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).symbols @@ -0,0 +1,116 @@ +//// [tests/cases/compiler/inferTupleFromBindingPattern.ts] //// + +=== inferTupleFromBindingPattern.ts === +declare function f(cb: () => T): T; +>f : Symbol(f, Decl(inferTupleFromBindingPattern.ts, 0, 0)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19)) +>cb : Symbol(cb, Decl(inferTupleFromBindingPattern.ts, 0, 22)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19)) + +const [e1, e2, e3] = f(() => [1, "hi", true]); +>e1 : Symbol(e1, Decl(inferTupleFromBindingPattern.ts, 1, 7)) +>e2 : Symbol(e2, Decl(inferTupleFromBindingPattern.ts, 1, 10)) +>e3 : Symbol(e3, Decl(inferTupleFromBindingPattern.ts, 1, 14)) +>f : Symbol(f, Decl(inferTupleFromBindingPattern.ts, 0, 0)) + +// repro from #42969 +declare const f2: (t: T) => [T, string[]]; +>f2 : Symbol(f2, Decl(inferTupleFromBindingPattern.ts, 4, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 4, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 4, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 4, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 4, 19)) + +const [[f2e1]] = f2(['1']); +>f2e1 : Symbol(f2e1, Decl(inferTupleFromBindingPattern.ts, 5, 8)) +>f2 : Symbol(f2, Decl(inferTupleFromBindingPattern.ts, 4, 13)) + +f2e1.toLowerCase(); +>f2e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f2e1 : Symbol(f2e1, Decl(inferTupleFromBindingPattern.ts, 5, 8)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f3: (t: T) => [[T, string[]]]; +>f3 : Symbol(f3, Decl(inferTupleFromBindingPattern.ts, 8, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 8, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 8, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 8, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 8, 19)) + +const [[[f3e1]]] = f3(['1']); +>f3e1 : Symbol(f3e1, Decl(inferTupleFromBindingPattern.ts, 9, 9)) +>f3 : Symbol(f3, Decl(inferTupleFromBindingPattern.ts, 8, 13)) + +f3e1.toLowerCase(); +>f3e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f3e1 : Symbol(f3e1, Decl(inferTupleFromBindingPattern.ts, 9, 9)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f4: (t: T) => [T, number, string[]]; +>f4 : Symbol(f4, Decl(inferTupleFromBindingPattern.ts, 12, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 12, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 12, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 12, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 12, 19)) + +const [[f4e1], ...f4rest1] = f4(['1']); +>f4e1 : Symbol(f4e1, Decl(inferTupleFromBindingPattern.ts, 13, 8)) +>f4rest1 : Symbol(f4rest1, Decl(inferTupleFromBindingPattern.ts, 13, 14)) +>f4 : Symbol(f4, Decl(inferTupleFromBindingPattern.ts, 12, 13)) + +f4e1.toLowerCase(); +>f4e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f4e1 : Symbol(f4e1, Decl(inferTupleFromBindingPattern.ts, 13, 8)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f5: (t: T) => [[T, number, string[]]]; +>f5 : Symbol(f5, Decl(inferTupleFromBindingPattern.ts, 16, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 16, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 16, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 16, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 16, 19)) + +const [[[f5e1], ...f5rest1]] = f5(['1']); +>f5e1 : Symbol(f5e1, Decl(inferTupleFromBindingPattern.ts, 17, 9)) +>f5rest1 : Symbol(f5rest1, Decl(inferTupleFromBindingPattern.ts, 17, 15)) +>f5 : Symbol(f5, Decl(inferTupleFromBindingPattern.ts, 16, 13)) + +f5e1.toLowerCase(); +>f5e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f5e1 : Symbol(f5e1, Decl(inferTupleFromBindingPattern.ts, 17, 9)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f6: (t: T) => [...T, number]; +>f6 : Symbol(f6, Decl(inferTupleFromBindingPattern.ts, 20, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 20, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 20, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 20, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 20, 19)) + +const [f6e1] = f6(['1']); +>f6e1 : Symbol(f6e1, Decl(inferTupleFromBindingPattern.ts, 21, 7)) +>f6 : Symbol(f6, Decl(inferTupleFromBindingPattern.ts, 20, 13)) + +f6e1.toLowerCase(); +>f6e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f6e1 : Symbol(f6e1, Decl(inferTupleFromBindingPattern.ts, 21, 7)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + +declare const f7: (t: T) => [number, ...T]; +>f7 : Symbol(f7, Decl(inferTupleFromBindingPattern.ts, 24, 13)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 24, 19)) +>t : Symbol(t, Decl(inferTupleFromBindingPattern.ts, 24, 39)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 24, 19)) +>T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 24, 19)) + +const [_, f7e1] = f7(['1']); +>_ : Symbol(_, Decl(inferTupleFromBindingPattern.ts, 25, 7)) +>f7e1 : Symbol(f7e1, Decl(inferTupleFromBindingPattern.ts, 25, 9)) +>f7 : Symbol(f7, Decl(inferTupleFromBindingPattern.ts, 24, 13)) + +f7e1.toLowerCase(); +>f7e1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) +>f7e1 : Symbol(f7e1, Decl(inferTupleFromBindingPattern.ts, 25, 9)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.es5.d.ts, --, --)) + diff --git a/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).types b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).types new file mode 100644 index 0000000000000..1f9b2deed7630 --- /dev/null +++ b/tests/baselines/reference/inferTupleFromBindingPattern(nouncheckedindexedaccess=true).types @@ -0,0 +1,125 @@ +//// [tests/cases/compiler/inferTupleFromBindingPattern.ts] //// + +=== inferTupleFromBindingPattern.ts === +declare function f(cb: () => T): T; +>f : (cb: () => T) => T +>cb : () => T + +const [e1, e2, e3] = f(() => [1, "hi", true]); +>e1 : number +>e2 : string +>e3 : boolean +>f(() => [1, "hi", true]) : [number, string, boolean] +>f : (cb: () => T) => T +>() => [1, "hi", true] : () => [number, string, boolean] +>[1, "hi", true] : [number, string, true] +>1 : 1 +>"hi" : "hi" +>true : true + +// repro from #42969 +declare const f2: (t: T) => [T, string[]]; +>f2 : (t: T) => [T, string[]] +>t : T + +const [[f2e1]] = f2(['1']); +>f2e1 : string +>f2(['1']) : [[string], string[]] +>f2 : (t: T) => [T, string[]] +>['1'] : [string] +>'1' : "1" + +f2e1.toLowerCase(); +>f2e1.toLowerCase() : string +>f2e1.toLowerCase : () => string +>f2e1 : string +>toLowerCase : () => string + +declare const f3: (t: T) => [[T, string[]]]; +>f3 : (t: T) => [[T, string[]]] +>t : T + +const [[[f3e1]]] = f3(['1']); +>f3e1 : string +>f3(['1']) : [[[string], string[]]] +>f3 : (t: T) => [[T, string[]]] +>['1'] : [string] +>'1' : "1" + +f3e1.toLowerCase(); +>f3e1.toLowerCase() : string +>f3e1.toLowerCase : () => string +>f3e1 : string +>toLowerCase : () => string + +declare const f4: (t: T) => [T, number, string[]]; +>f4 : (t: T) => [T, number, string[]] +>t : T + +const [[f4e1], ...f4rest1] = f4(['1']); +>f4e1 : string +>f4rest1 : [number, string[]] +>f4(['1']) : [[string], number, string[]] +>f4 : (t: T) => [T, number, string[]] +>['1'] : [string] +>'1' : "1" + +f4e1.toLowerCase(); +>f4e1.toLowerCase() : string +>f4e1.toLowerCase : () => string +>f4e1 : string +>toLowerCase : () => string + +declare const f5: (t: T) => [[T, number, string[]]]; +>f5 : (t: T) => [[T, number, string[]]] +>t : T + +const [[[f5e1], ...f5rest1]] = f5(['1']); +>f5e1 : string +>f5rest1 : [number, string[]] +>f5(['1']) : [[[string], number, string[]]] +>f5 : (t: T) => [[T, number, string[]]] +>['1'] : [string] +>'1' : "1" + +f5e1.toLowerCase(); +>f5e1.toLowerCase() : string +>f5e1.toLowerCase : () => string +>f5e1 : string +>toLowerCase : () => string + +declare const f6: (t: T) => [...T, number]; +>f6 : (t: T) => [...T, number] +>t : T + +const [f6e1] = f6(['1']); +>f6e1 : string +>f6(['1']) : [string, number] +>f6 : (t: T) => [...T, number] +>['1'] : [string] +>'1' : "1" + +f6e1.toLowerCase(); +>f6e1.toLowerCase() : string +>f6e1.toLowerCase : () => string +>f6e1 : string +>toLowerCase : () => string + +declare const f7: (t: T) => [number, ...T]; +>f7 : (t: T) => [number, ...T] +>t : T + +const [_, f7e1] = f7(['1']); +>_ : number +>f7e1 : string +>f7(['1']) : [number, string] +>f7 : (t: T) => [number, ...T] +>['1'] : [string] +>'1' : "1" + +f7e1.toLowerCase(); +>f7e1.toLowerCase() : string +>f7e1.toLowerCase : () => string +>f7e1 : string +>toLowerCase : () => string + diff --git a/tests/baselines/reference/inferTupleFromBindingPattern.js b/tests/baselines/reference/inferTupleFromBindingPattern.js deleted file mode 100644 index bab1caa7c1696..0000000000000 --- a/tests/baselines/reference/inferTupleFromBindingPattern.js +++ /dev/null @@ -1,9 +0,0 @@ -//// [tests/cases/compiler/inferTupleFromBindingPattern.ts] //// - -//// [inferTupleFromBindingPattern.ts] -declare function f(cb: () => T): T; -const [e1, e2, e3] = f(() => [1, "hi", true]); - - -//// [inferTupleFromBindingPattern.js] -var _a = f(function () { return [1, "hi", true]; }), e1 = _a[0], e2 = _a[1], e3 = _a[2]; diff --git a/tests/baselines/reference/inferTupleFromBindingPattern.symbols b/tests/baselines/reference/inferTupleFromBindingPattern.symbols deleted file mode 100644 index bba0820623cda..0000000000000 --- a/tests/baselines/reference/inferTupleFromBindingPattern.symbols +++ /dev/null @@ -1,16 +0,0 @@ -//// [tests/cases/compiler/inferTupleFromBindingPattern.ts] //// - -=== inferTupleFromBindingPattern.ts === -declare function f(cb: () => T): T; ->f : Symbol(f, Decl(inferTupleFromBindingPattern.ts, 0, 0)) ->T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19)) ->cb : Symbol(cb, Decl(inferTupleFromBindingPattern.ts, 0, 22)) ->T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19)) ->T : Symbol(T, Decl(inferTupleFromBindingPattern.ts, 0, 19)) - -const [e1, e2, e3] = f(() => [1, "hi", true]); ->e1 : Symbol(e1, Decl(inferTupleFromBindingPattern.ts, 1, 7)) ->e2 : Symbol(e2, Decl(inferTupleFromBindingPattern.ts, 1, 10)) ->e3 : Symbol(e3, Decl(inferTupleFromBindingPattern.ts, 1, 14)) ->f : Symbol(f, Decl(inferTupleFromBindingPattern.ts, 0, 0)) - diff --git a/tests/baselines/reference/inferTupleFromBindingPattern.types b/tests/baselines/reference/inferTupleFromBindingPattern.types deleted file mode 100644 index f05074b07147d..0000000000000 --- a/tests/baselines/reference/inferTupleFromBindingPattern.types +++ /dev/null @@ -1,19 +0,0 @@ -//// [tests/cases/compiler/inferTupleFromBindingPattern.ts] //// - -=== inferTupleFromBindingPattern.ts === -declare function f(cb: () => T): T; ->f : (cb: () => T) => T ->cb : () => T - -const [e1, e2, e3] = f(() => [1, "hi", true]); ->e1 : number ->e2 : string ->e3 : boolean ->f(() => [1, "hi", true]) : [number, string, boolean] ->f : (cb: () => T) => T ->() => [1, "hi", true] : () => [number, string, boolean] ->[1, "hi", true] : [number, string, true] ->1 : 1 ->"hi" : "hi" ->true : true - diff --git a/tests/baselines/reference/missingAndExcessProperties.errors.txt b/tests/baselines/reference/missingAndExcessProperties.errors.txt index f0448190c907a..6244f100eca17 100644 --- a/tests/baselines/reference/missingAndExcessProperties.errors.txt +++ b/tests/baselines/reference/missingAndExcessProperties.errors.txt @@ -1,17 +1,17 @@ missingAndExcessProperties.ts(3,11): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. missingAndExcessProperties.ts(3,14): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -missingAndExcessProperties.ts(4,11): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type 'any', but here has type 'number'. +missingAndExcessProperties.ts(4,11): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type 'unknown', but here has type 'number'. missingAndExcessProperties.ts(4,18): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. missingAndExcessProperties.ts(5,11): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -missingAndExcessProperties.ts(5,14): error TS2403: Subsequent variable declarations must have the same type. Variable 'y' must be of type 'any', but here has type 'number'. -missingAndExcessProperties.ts(6,11): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type 'any', but here has type 'number'. -missingAndExcessProperties.ts(6,18): error TS2403: Subsequent variable declarations must have the same type. Variable 'y' must be of type 'any', but here has type 'number'. +missingAndExcessProperties.ts(5,14): error TS2403: Subsequent variable declarations must have the same type. Variable 'y' must be of type 'unknown', but here has type 'number'. +missingAndExcessProperties.ts(6,11): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type 'unknown', but here has type 'number'. +missingAndExcessProperties.ts(6,18): error TS2403: Subsequent variable declarations must have the same type. Variable 'y' must be of type 'unknown', but here has type 'number'. missingAndExcessProperties.ts(12,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. missingAndExcessProperties.ts(12,11): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. missingAndExcessProperties.ts(13,18): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. missingAndExcessProperties.ts(14,8): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -missingAndExcessProperties.ts(21,25): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: any; }'. -missingAndExcessProperties.ts(22,19): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: any; }'. +missingAndExcessProperties.ts(21,25): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: unknown; }'. +missingAndExcessProperties.ts(22,19): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: unknown; }'. missingAndExcessProperties.ts(29,14): error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{}'. missingAndExcessProperties.ts(29,20): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{}'. missingAndExcessProperties.ts(30,22): error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: number; }'. @@ -28,7 +28,7 @@ missingAndExcessProperties.ts(31,16): error TS2353: Object literal may only spec !!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value. var { x = 1, y } = {}; ~ -!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type 'any', but here has type 'number'. +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type 'unknown', but here has type 'number'. !!! related TS6203 missingAndExcessProperties.ts:3:11: 'x' was also declared here. ~ !!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value. @@ -36,14 +36,14 @@ missingAndExcessProperties.ts(31,16): error TS2353: Object literal may only spec ~ !!! error TS2525: Initializer provides no value for this binding element and the binding element has no default value. ~ -!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'y' must be of type 'any', but here has type 'number'. +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'y' must be of type 'unknown', but here has type 'number'. !!! related TS6203 missingAndExcessProperties.ts:3:14: 'y' was also declared here. var { x = 1, y = 1 } = {}; ~ -!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type 'any', but here has type 'number'. +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type 'unknown', but here has type 'number'. !!! related TS6203 missingAndExcessProperties.ts:3:11: 'x' was also declared here. ~ -!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'y' must be of type 'any', but here has type 'number'. +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'y' must be of type 'unknown', but here has type 'number'. !!! related TS6203 missingAndExcessProperties.ts:3:14: 'y' was also declared here. } @@ -69,10 +69,10 @@ missingAndExcessProperties.ts(31,16): error TS2353: Object literal may only spec var { } = { x: 0, y: 0 }; var { x } = { x: 0, y: 0 }; ~ -!!! error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'y' does not exist in type '{ x: unknown; }'. var { y } = { x: 0, y: 0 }; ~ -!!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: any; }'. +!!! error TS2353: Object literal may only specify known properties, and 'x' does not exist in type '{ y: unknown; }'. var { x, y } = { x: 0, y: 0 }; } diff --git a/tests/baselines/reference/missingAndExcessProperties.types b/tests/baselines/reference/missingAndExcessProperties.types index d06630fa66146..06053702f86e7 100644 --- a/tests/baselines/reference/missingAndExcessProperties.types +++ b/tests/baselines/reference/missingAndExcessProperties.types @@ -6,26 +6,26 @@ function f1() { >f1 : () => void var { x, y } = {}; ->x : any ->y : any ->{} : { x: any; y: any; } +>x : unknown +>y : unknown +>{} : { x: unknown; y: unknown; } var { x = 1, y } = {}; ->x : any +>x : unknown >1 : 1 ->y : any ->{} : { x?: number; y: any; } +>y : unknown +>{} : { x?: number; y: unknown; } var { x, y = 1 } = {}; ->x : any ->y : any +>x : unknown +>y : unknown >1 : 1 ->{} : { x: any; y?: number; } +>{} : { x: unknown; y?: number; } var { x = 1, y = 1 } = {}; ->x : any +>x : unknown >1 : 1 ->y : any +>y : unknown >1 : 1 >{} : { x?: number; y?: number; } } diff --git a/tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening.ts b/tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening1.ts similarity index 62% rename from tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening.ts rename to tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening1.ts index a86b8918ebf54..481a63af2c0d6 100644 --- a/tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening.ts +++ b/tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening1.ts @@ -1,3 +1,3 @@ declare function pick(keys: T[], obj?: O): Pick; const _ = pick(['b'], { a: 'a', b: 'b' }); // T: "b" -const { } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" | "a" ??? (before fix) +const { } = pick(['b'], { a: 'a', b: 'b' }); // T: "b" diff --git a/tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening2.ts b/tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening2.ts new file mode 100644 index 0000000000000..b63be9437234e --- /dev/null +++ b/tests/cases/compiler/bindingPatternContextualTypeDoesNotCauseWidening2.ts @@ -0,0 +1,40 @@ +// @strict: true +// @noEmit: true + +// https://github.com/microsoft/TypeScript/issues/56771 + +declare function fn1(t: T): T; +const { A } = fn1({ A: { a: "A" } }); +A.a; + +declare function fn2(t: T): T; +const { A: [nested] } = fn2({ A: ["a"] }); + +declare function fn3(obj: T): T; +const { a: [a3] } = fn3({ a: [1, ""], b: "" }); + +declare function fn4(obj: T): T; +const [{ a: a4 }] = fn4([{ a: "", b: 10 }, { a: true, b: "" }]); + +declare function fn5< + O extends { a?: "a"; b?: "b1" | "b2"; c?: "c" }[], + T extends keyof O[number], +>( + keys: T[], + obj?: O, +): { + [K in keyof O]: Pick; +} +const [{ b: b5_1 }, { b: b5_2 }] = fn5(["b"], [{ a: "a", b: "b1" }, { b: "b2", c: "c" }]); + +declare function fn6< + O extends { a?: "valA", b?: "valB" | "valC" } | null, + T extends keyof O +>( + keys: T[], + obj?: O, +): Pick & { pickedKeys: T }; +const { b: b6, pickedKeys } = fn6(["b"], { a: "valA", b: "valB" }); + +declare function fn7(obj: T): T +const { a7 } = fn7({ a7: 'a' }) \ No newline at end of file diff --git a/tests/cases/compiler/inferTupleFromBindingPattern.ts b/tests/cases/compiler/inferTupleFromBindingPattern.ts index 7c0c1dea98193..759a458426825 100644 --- a/tests/cases/compiler/inferTupleFromBindingPattern.ts +++ b/tests/cases/compiler/inferTupleFromBindingPattern.ts @@ -1,2 +1,30 @@ +// @strict: true +// @noUncheckedIndexedAccess: true, false + declare function f(cb: () => T): T; const [e1, e2, e3] = f(() => [1, "hi", true]); + +// repro from #42969 +declare const f2: (t: T) => [T, string[]]; +const [[f2e1]] = f2(['1']); +f2e1.toLowerCase(); + +declare const f3: (t: T) => [[T, string[]]]; +const [[[f3e1]]] = f3(['1']); +f3e1.toLowerCase(); + +declare const f4: (t: T) => [T, number, string[]]; +const [[f4e1], ...f4rest1] = f4(['1']); +f4e1.toLowerCase(); + +declare const f5: (t: T) => [[T, number, string[]]]; +const [[[f5e1], ...f5rest1]] = f5(['1']); +f5e1.toLowerCase(); + +declare const f6: (t: T) => [...T, number]; +const [f6e1] = f6(['1']); +f6e1.toLowerCase(); + +declare const f7: (t: T) => [number, ...T]; +const [_, f7e1] = f7(['1']); +f7e1.toLowerCase(); diff --git a/tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash1.ts b/tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash1.ts new file mode 100644 index 0000000000000..e8443a155f6c4 --- /dev/null +++ b/tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash1.ts @@ -0,0 +1,21 @@ +/// + +// @strict: true +//// declare function pick(keys: T[], obj?: O): Pick; +//// const _ = pick/*1*/(['b'], { a: 'a', b: 'b' }); +//// const { } = pick/*2*/(['b'], { a: 'a', b: 'b' }); +//// const { b } = pick/*3*/(['b'], { a: 'a', b: 'b' }); + +const expectedText = `function pick<{ + a: string; + b: string; +}, "b">(keys: "b"[], obj?: { + a: string; + b: string; +} | undefined): Pick<{ + a: string; + b: string; +}, "b">`; +verify.quickInfoAt("1", expectedText); +verify.quickInfoAt("2", expectedText); +verify.quickInfoAt("3", expectedText); diff --git a/tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash2.ts b/tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash2.ts new file mode 100644 index 0000000000000..2d7a0d042d885 --- /dev/null +++ b/tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash2.ts @@ -0,0 +1,21 @@ +/// + +// @strict: true +//// declare function constrainedPick(keys: T[], obj?: O): Pick; +//// const _ = constrainedPick/*1*/(['b'], { a: 'a', b: 'b' }); +//// const { } = constrainedPick/*2*/(['b'], { a: 'a', b: 'b' }); +//// const { b } = constrainedPick/*3*/(['b'], { a: 'a', b: 'b' }); + +const expectedText = `function constrainedPick<{ + a: "a"; + b: "b"; +}, "b">(keys: "b"[], obj?: { + a: "a"; + b: "b"; +} | undefined): Pick<{ + a: "a"; + b: "b"; +}, "b">`; +verify.quickInfoAt("1", expectedText); +verify.quickInfoAt("2", expectedText); +verify.quickInfoAt("3", expectedText); diff --git a/tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash3.ts b/tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash3.ts new file mode 100644 index 0000000000000..db12718e41375 --- /dev/null +++ b/tests/cases/fourslash/bindingPatternContextualTypeDoesNotCauseWideningFourslash3.ts @@ -0,0 +1,21 @@ +/// + +// @strict: true +//// declare function constrainedPick(keys: T[], obj?: O): Pick; +//// const _ = constrainedPick/*1*/(['b'], { a: 'a', b: 'b' }); +//// const { } = constrainedPick/*2*/(['b'], { a: 'a', b: 'b' }); +//// const { b } = constrainedPick/*3*/(['b'], { a: 'a', b: 'b' }); + +const expectedText = `function constrainedPick<{ + a: "a"; + b: "b"; +}, "b">(keys: "b"[], obj?: { + a: "a"; + b: "b"; +} | undefined): Pick<{ + a: "a"; + b: "b"; +}, "b">`; +verify.quickInfoAt("1", expectedText); +verify.quickInfoAt("2", expectedText); +verify.quickInfoAt("3", expectedText); diff --git a/tests/cases/fourslash/codeFixAddMissingMember20.ts b/tests/cases/fourslash/codeFixAddMissingMember20.ts index b45d596401654..f54b611ebc336 100644 --- a/tests/cases/fourslash/codeFixAddMissingMember20.ts +++ b/tests/cases/fourslash/codeFixAddMissingMember20.ts @@ -33,7 +33,7 @@ verify.codeFix({ description: "Declare property 'foo'", index: 0, newFileContent: `class C { - foo: { many01: any; many02: any; many03: any; many04: any; many05: any; many06: any; many07: any; many08: any; many09: any; many10: any; many11: any; many12: any; many13: any; many14: any; many15: any; many16: any; many17: any; many18: any; many19: any; many20: any; many21: any; many22: any; }; + foo: { many01: unknown; many02: unknown; many03: unknown; many04: unknown; many05: unknown; many06: unknown; many07: unknown; many08: unknown; many09: unknown; many10: unknown; many11: unknown; many12: unknown; many13: unknown; many14: unknown; many15: unknown; many16: unknown; many17: unknown; many18: unknown; many19: unknown; many20: unknown; many21: unknown; many22: unknown; }; method() { const { many01, diff --git a/tests/cases/fourslash/codeFixInferFromUsageJSDestructuring.ts b/tests/cases/fourslash/codeFixInferFromUsageJSDestructuring.ts index fb394c3507af2..937c42daa15e5 100644 --- a/tests/cases/fourslash/codeFixInferFromUsageJSDestructuring.ts +++ b/tests/cases/fourslash/codeFixInferFromUsageJSDestructuring.ts @@ -10,7 +10,7 @@ verify.codeFix({ description: "Infer parameter types from usage", index: 0, newFileContent: `/** - * @param {{ type: any; }} message + * @param {{ type: unknown; }} message */ function formatter(message) { const { type } = false ? { type: message } : message; From 8f0a2c945ed1ee1fac8bda8dfffb7d394e3eed63 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Tue, 26 Dec 2023 09:44:37 +0100 Subject: [PATCH 2/2] simplify one of the checks --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 83829cee9bf08..08fced2c302d3 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -26125,7 +26125,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (context.signature) { const inferredCovariantType = inference.candidates ? getCovariantInference(inference, context.signature) : undefined; const inferredContravariantType = inference.contraCandidates ? getContravariantInference(inference) : undefined; - if (!inferredContravariantType && inference.candidates?.length === 1 && inference.candidates[0].pattern) { + if (inferredCovariantType?.pattern) { isFromBindingPattern = true; inferredType = inferredCovariantType; }