From 643351ca2d3618e9ce02a6b91901552ba12f5468 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 23 Aug 2019 09:54:55 -0400 Subject: [PATCH 01/25] Support deferred resolution of type arguments in type references --- src/compiler/checker.ts | 149 ++++++++++++++++++++++------------- src/compiler/symbolWalker.ts | 5 +- src/compiler/types.ts | 4 +- 3 files changed, 100 insertions(+), 58 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 53f96d507b848..b7e645e99d847 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -508,6 +508,7 @@ namespace ts { getIndexTypeOfStructuredType, getConstraintOfTypeParameter, getFirstIdentifier, + getTypeArguments, ), getAmbientModules, getJsxIntrinsicTagNamesAt, @@ -3539,6 +3540,7 @@ namespace ts { } function createNodeBuilder() { + let depth = 0; return { typeToTypeNode: (type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => typeToTypeNodeHelper(type, context)), @@ -3700,6 +3702,12 @@ namespace ts { return createThis(); } + if (!inTypeAlias && type.aliasSymbol && (context.flags & NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) { + const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context); + if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & SymbolFlags.Class)) return createTypeReferenceNode(createIdentifier(""), typeArgumentNodes); + return symbolToTypeNode(type.aliasSymbol, context, SymbolFlags.Type, typeArgumentNodes); + } + const objectFlags = getObjectFlags(type); if (objectFlags & ObjectFlags.Reference) { @@ -3722,11 +3730,6 @@ namespace ts { ? symbolToTypeNode(type.symbol, context, SymbolFlags.Type) : createTypeReferenceNode(createIdentifier("?"), /*typeArguments*/ undefined); } - if (!inTypeAlias && type.aliasSymbol && (context.flags & NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) { - const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context); - if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & SymbolFlags.Class)) return createTypeReferenceNode(createIdentifier(""), typeArgumentNodes); - return symbolToTypeNode(type.aliasSymbol, context, SymbolFlags.Type, typeArgumentNodes); - } if (type.flags & (TypeFlags.Union | TypeFlags.Intersection)) { const types = type.flags & TypeFlags.Union ? formatUnionTypes((type).types) : (type).types; if (length(types) === 1) { @@ -3904,14 +3907,18 @@ namespace ts { } function typeReferenceToTypeNode(type: TypeReference) { - const typeArguments: ReadonlyArray = type.typeArguments || emptyArray; + const typeArguments: ReadonlyArray = getTypeArguments(type); if (type.target === globalArrayType || type.target === globalReadonlyArrayType) { if (context.flags & NodeBuilderFlags.WriteArrayAsGenericType) { - const typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context); - return createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]); + depth++; + const typeArgumentNode = typeToTypeNodeHelper(depth >= 5 ? anyType : typeArguments[0], context); + depth--; + createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]); } - const elementType = typeToTypeNodeHelper(typeArguments[0], context); + depth++; + const elementType = typeToTypeNodeHelper(depth >= 5 ? anyType : typeArguments[0], context); + depth--; const arrayType = createArrayTypeNode(elementType); return type.target === globalArrayType ? arrayType : createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, arrayType); } @@ -6231,7 +6238,7 @@ namespace ts { const signatures = getSignaturesOfType(type, SignatureKind.Construct); if (signatures.length === 1) { const s = signatures[0]; - return !s.typeParameters && s.parameters.length === 1 && s.hasRestParameter && getTypeOfParameter(s.parameters[0]) === anyArrayType; + return !s.typeParameters && s.parameters.length === 1 && s.hasRestParameter && getElementTypeOfArrayType(getTypeOfParameter(s.parameters[0])) === anyType; } return false; } @@ -6402,7 +6409,7 @@ namespace ts { const outerTypeParameters = (type).outerTypeParameters; if (outerTypeParameters) { const last = outerTypeParameters.length - 1; - const typeArguments = (type).typeArguments!; + const typeArguments = getTypeArguments(type); return outerTypeParameters[last].symbol !== typeArguments[last].symbol; } return true; @@ -6493,7 +6500,7 @@ namespace ts { (type).instantiations = createMap(); (type).instantiations.set(getTypeListId(type.typeParameters), type); (type).target = type; - (type).typeArguments = type.typeParameters; + (type).resolvedTypeArguments = type.typeParameters; type.thisType = createTypeParameter(symbol); type.thisType.isThisType = true; type.thisType.constraint = type; @@ -7017,7 +7024,7 @@ namespace ts { function getTypeWithThisArgument(type: Type, thisArgument?: Type, needApparentType?: boolean): Type { if (getObjectFlags(type) & ObjectFlags.Reference) { const target = (type).target; - const typeArguments = (type).typeArguments; + const typeArguments = getTypeArguments(type); if (length(target.typeParameters) === length(typeArguments)) { const ref = createTypeReference(target, concatenate(typeArguments, [thisArgument || target.thisType!])); return needApparentType ? getApparentType(ref) : ref; @@ -7082,9 +7089,9 @@ namespace ts { function resolveTypeReferenceMembers(type: TypeReference): void { const source = resolveDeclaredMembers(type.target); const typeParameters = concatenate(source.typeParameters!, [source.thisType!]); - const typeArguments = type.typeArguments && type.typeArguments.length === typeParameters.length ? - type.typeArguments : concatenate(type.typeArguments, [type]); - resolveObjectTypeMembers(type, source, typeParameters, typeArguments); + const typeArguments = getTypeArguments(type); + const paddedTypeArguments = typeArguments.length === typeParameters.length ? typeArguments : concatenate(typeArguments, [type]); + resolveObjectTypeMembers(type, source, typeParameters, paddedTypeArguments); } function createSignature( @@ -7135,7 +7142,7 @@ namespace ts { const restParameter = sig.parameters[restIndex]; const restType = getTypeOfSymbol(restParameter); if (isTupleType(restType)) { - const elementTypes = restType.typeArguments || emptyArray; + const elementTypes = getTypeArguments(restType); const minLength = restType.target.minLength; const tupleRestIndex = restType.target.hasRestElement ? elementTypes.length - 1 : -1; const restParams = map(elementTypes, (t, i) => { @@ -9056,7 +9063,7 @@ namespace ts { target.instantiations.set(id, type); type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, /*excludeKinds*/ 0) : 0; type.target = target; - type.typeArguments = typeArguments; + type.resolvedTypeArguments = typeArguments; } return type; } @@ -9066,10 +9073,28 @@ namespace ts { type.symbol = source.symbol; type.objectFlags = source.objectFlags; type.target = source.target; - type.typeArguments = source.typeArguments; + type.resolvedTypeArguments = source.resolvedTypeArguments; return type; } + function createDeferredTypeReference(target: GenericType, typeArgumentNodes: ReadonlyArray, mapper?: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: ReadonlyArray): TypeReference { + const type = createObjectType(ObjectFlags.Reference, target.symbol); + type.target = target; + type.typeArgumentNodes = typeArgumentNodes; + type.mapper = mapper; + type.aliasSymbol = aliasSymbol; + type.aliasTypeArguments = aliasTypeArguments; + return type; + } + + function getTypeArguments(type: TypeReference): ReadonlyArray { + if (!type.resolvedTypeArguments) { + const typeArguments = type.typeArgumentNodes ? map(type.typeArgumentNodes, getTypeFromTypeNode) : emptyArray; + type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments; + } + return type.resolvedTypeArguments; + } + function getTypeReferenceArity(type: TypeReference): number { return length(type.target.typeParameters); } @@ -9559,7 +9584,10 @@ namespace ts { function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type { const links = getNodeLinks(node); if (!links.resolvedType) { - links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType), isReadonlyTypeOperator(node.parent)); + const target = isReadonlyTypeOperator(node.parent) ? globalReadonlyArrayType : globalArrayType; + const aliasSymbol = getAliasSymbolForTypeNode(node); + const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + links.resolvedType = createDeferredTypeReference(target, [node.elementType], /*mapper*/ undefined, aliasSymbol, aliasTypeArguments); } return links.resolvedType; } @@ -9603,7 +9631,7 @@ namespace ts { type.instantiations = createMap(); type.instantiations.set(getTypeListId(type.typeParameters), type); type.target = type; - type.typeArguments = type.typeParameters; + type.resolvedTypeArguments = type.typeParameters; type.thisType = createTypeParameter(); type.thisType.isThisType = true; type.thisType.constraint = type; @@ -9659,7 +9687,7 @@ namespace ts { index = Math.min(index, getTypeReferenceArity(type) - 1); } return createTupleType( - (type.typeArguments || emptyArray).slice(index), + getTypeArguments(type).slice(index), Math.max(0, tuple.minLength - index), tuple.hasRestElement, tuple.readonly, @@ -11507,7 +11535,7 @@ namespace ts { function instantiateMappedTupleType(tupleType: TupleTypeReference, mappedType: MappedType, mapper: TypeMapper) { const minLength = tupleType.target.minLength; - const elementTypes = map(tupleType.typeArguments || emptyArray, (_, i) => + const elementTypes = map(getTypeArguments(tupleType), (_, i) => instantiateMappedTypeTemplate(mappedType, getLiteralType("" + i), i >= minLength, mapper)); const modifiers = getMappedTypeModifiers(mappedType); const newMinLength = modifiers & MappedTypeModifiers.IncludeOptional ? 0 : @@ -11616,9 +11644,19 @@ namespace ts { return getAnonymousTypeInstantiation(type, mapper); } if (objectFlags & ObjectFlags.Reference) { - const typeArguments = (type).typeArguments; - const newTypeArguments = instantiateTypes(typeArguments, mapper); - return newTypeArguments !== typeArguments ? createTypeReference((type).target, newTypeArguments) : type; + const resolvedTypeArguments = (type).resolvedTypeArguments; + if (resolvedTypeArguments) { + const newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper); + return newTypeArguments !== resolvedTypeArguments ? createTypeReference((type).target, newTypeArguments) : type; + } + else { + const typeArgumentNodes = (type).typeArgumentNodes; + if (typeArgumentNodes) { + const combinedMapper = combineTypeMappers((type).mapper, mapper); + return createDeferredTypeReference((type).target, typeArgumentNodes, combinedMapper, + (type).aliasSymbol, instantiateTypes((type).aliasTypeArguments, combinedMapper)); + } + } } return type; } @@ -13284,8 +13322,8 @@ namespace ts { source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol) { propagateSidebandVarianceFlags(source.aliasTypeArguments, getAliasVariances(source.aliasSymbol)); } - if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (source).target === (target).target && length((source).typeArguments)) { - propagateSidebandVarianceFlags((source).typeArguments!, getVariances((source).target)); + if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && (source).target === (target).target && length(getTypeArguments(source))) { + propagateSidebandVarianceFlags(getTypeArguments(source), getVariances((source).target)); } } return related === RelationComparisonResult.Succeeded ? Ternary.True : Ternary.False; @@ -13569,7 +13607,7 @@ namespace ts { // type references (which are intended by be compared structurally). Obtain the variance // information for the type parameters and relate the type arguments accordingly. const variances = getVariances((source).target); - const varianceResult = relateVariances((source).typeArguments, (target).typeArguments, variances, isIntersectionConstituent); + const varianceResult = relateVariances(getTypeArguments(source), getTypeArguments(target), variances, isIntersectionConstituent); if (varianceResult !== undefined) { return varianceResult; } @@ -13995,8 +14033,9 @@ namespace ts { } const targetCount = getTypeReferenceArity(target) - 1; const sourceCount = getTypeReferenceArity(source) - (sourceRestType ? 1 : 0); + const sourceTypeArguments = getTypeArguments(source); for (let i = targetCount; i < sourceCount; i++) { - const related = isRelatedTo((source).typeArguments![i], targetRestType, reportErrors); + const related = isRelatedTo(sourceTypeArguments[i], targetRestType, reportErrors); if (!related) { if (reportErrors) { reportError(Diagnostics.Property_0_is_incompatible_with_rest_element_type, "" + i); @@ -14408,7 +14447,7 @@ namespace ts { } function isTypeReferenceWithGenericArguments(type: Type): boolean { - return !!(getObjectFlags(type) & ObjectFlags.Reference) && some((type).typeArguments, t => isUnconstrainedTypeParameter(t) || isTypeReferenceWithGenericArguments(t)); + return !!(getObjectFlags(type) & ObjectFlags.Reference) && some(getTypeArguments(type), t => isUnconstrainedTypeParameter(t) || isTypeReferenceWithGenericArguments(t)); } /** @@ -14417,7 +14456,7 @@ namespace ts { */ function getTypeReferenceId(type: TypeReference, typeParameters: Type[], depth = 0) { let result = "" + type.target.id; - for (const t of type.typeArguments!) { + for (const t of getTypeArguments(type)) { if (isUnconstrainedTypeParameter(t)) { let index = typeParameters.indexOf(t); if (index < 0) { @@ -14688,7 +14727,7 @@ namespace ts { } function getElementTypeOfArrayType(type: Type): Type | undefined { - return isArrayType(type) && (type as TypeReference).typeArguments ? (type as TypeReference).typeArguments![0] : undefined; + return isArrayType(type) ? getTypeArguments(type as TypeReference)[0] : undefined; } function isArrayLikeType(type: Type): boolean { @@ -14698,7 +14737,7 @@ namespace ts { } function isEmptyArrayLiteralType(type: Type): boolean { - const elementType = isArrayType(type) ? (type).typeArguments![0] : undefined; + const elementType = isArrayType(type) ? getTypeArguments(type)[0] : undefined; return elementType === undefinedWideningType || elementType === implicitNeverType; } @@ -14796,7 +14835,7 @@ namespace ts { } function getRestTypeOfTupleType(type: TupleTypeReference) { - return type.target.hasRestElement ? type.typeArguments![type.target.typeParameters!.length - 1] : undefined; + return type.target.hasRestElement ? getTypeArguments(type)[type.target.typeParameters!.length - 1] : undefined; } function getRestArrayTypeOfTupleType(type: TupleTypeReference) { @@ -15085,7 +15124,7 @@ namespace ts { result = getIntersectionType(sameMap((type).types, getWidenedType)); } else if (isArrayType(type) || isTupleType(type)) { - result = createTypeReference((type).target, sameMap((type).typeArguments, getWidenedType)); + result = createTypeReference((type).target, sameMap(getTypeArguments(type), getWidenedType)); } if (result && context === undefined) { type.widened = result; @@ -15122,7 +15161,7 @@ namespace ts { } } if (isArrayType(type) || isTupleType(type)) { - for (const t of (type).typeArguments!) { + for (const t of getTypeArguments(type)) { if (reportWideningErrorsInType(t)) { errorReported = true; } @@ -15332,7 +15371,7 @@ namespace ts { function couldContainTypeVariables(type: Type): boolean { const objectFlags = getObjectFlags(type); return !!(type.flags & TypeFlags.Instantiable || - objectFlags & ObjectFlags.Reference && forEach((type).typeArguments, couldContainTypeVariables) || + objectFlags & ObjectFlags.Reference && forEach(getTypeArguments(type), couldContainTypeVariables) || objectFlags & ObjectFlags.Anonymous && type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) && type.symbol.declarations || objectFlags & ObjectFlags.Mapped || type.flags & TypeFlags.UnionOrIntersection && !(type.flags & TypeFlags.EnumLiteral) && couldUnionOrIntersectionContainTypeVariables(type)); @@ -15408,10 +15447,10 @@ namespace ts { // 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((source).typeArguments![0], target, constraint), isReadonlyArrayType(source)); + return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source)); } if (isTupleType(source)) { - const elementTypes = map(source.typeArguments || emptyArray, t => inferReverseMappedType(t, target, constraint)); + const elementTypes = map(getTypeArguments(source), t => inferReverseMappedType(t, target, constraint)); const minLength = getMappedTypeModifiers(target) & MappedTypeModifiers.IncludeOptional ? getTypeReferenceArity(source) - (source.target.hasRestElement ? 1 : 0) : source.target.minLength; return createTupleType(elementTypes, minLength, source.target.hasRestElement, source.target.readonly, source.target.associatedNames); @@ -15625,7 +15664,7 @@ namespace ts { if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.Reference && ( (source).target === (target).target || isArrayType(source) && isArrayType(target))) { // If source and target are references to the same generic type, infer from type arguments - inferFromTypeArguments((source).typeArguments || emptyArray, (target).typeArguments || emptyArray, getVariances((source).target)); + inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances((source).target)); } else if (source.flags & TypeFlags.Index && target.flags & TypeFlags.Index) { contravariant = !contravariant; @@ -15945,10 +15984,10 @@ namespace ts { const targetRestType = getRestTypeOfTupleType(target); const fixedLength = targetLength < sourceLength || sourceRestType ? targetLength : sourceLength; for (let i = 0; i < fixedLength; i++) { - inferFromTypes(i < sourceLength ? (source).typeArguments![i] : sourceRestType!, target.typeArguments![i]); + inferFromTypes(i < sourceLength ? getTypeArguments(source)[i] : sourceRestType!, getTypeArguments(target)[i]); } if (targetRestType) { - const types = fixedLength < sourceLength ? (source).typeArguments!.slice(fixedLength, sourceLength) : []; + const types = fixedLength < sourceLength ? getTypeArguments(source).slice(fixedLength, sourceLength) : []; if (sourceRestType) { types.push(sourceRestType); } @@ -18598,7 +18637,7 @@ namespace ts { } function getThisTypeArgument(type: Type): Type | undefined { - return getObjectFlags(type) & ObjectFlags.Reference && (type).target === globalThisType ? (type).typeArguments![0] : undefined; + return getObjectFlags(type) & ObjectFlags.Reference && (type).target === globalThisType ? getTypeArguments(type)[0] : undefined; } function getThisTypeFromContextualType(type: Type): Type | undefined { @@ -21651,7 +21690,7 @@ namespace ts { const spreadArgument = args[length - 1]; const type = flowLoopCount ? checkExpression(spreadArgument.expression) : checkExpressionCached(spreadArgument.expression); if (isTupleType(type)) { - const typeArguments = (type).typeArguments || emptyArray; + const typeArguments = getTypeArguments(type); const restIndex = type.target.hasRestElement ? typeArguments.length - 1 : -1; const syntheticArgs = map(typeArguments, (t, i) => createSyntheticExpression(spreadArgument, t, /*isSpread*/ i === restIndex)); return concatenate(args.slice(0, length - 1), syntheticArgs); @@ -23199,7 +23238,7 @@ namespace ts { // otherwise would return the type 'undefined'). const restType = getTypeOfSymbol(signature.parameters[paramCount]); const index = pos - paramCount; - if (!isTupleType(restType) || restType.target.hasRestElement || index < (restType.typeArguments || emptyArray).length) { + if (!isTupleType(restType) || restType.target.hasRestElement || index < getTypeArguments(restType).length) { return getIndexedAccessType(restType, getLiteralType(index)); } } @@ -23233,7 +23272,7 @@ namespace ts { if (signature.hasRestParameter) { const restType = getTypeOfSymbol(signature.parameters[length - 1]); if (isTupleType(restType)) { - return length + (restType.typeArguments || emptyArray).length - 1; + return length + getTypeArguments(restType).length - 1; } } return length; @@ -24975,7 +25014,7 @@ namespace ts { function padTupleType(type: TupleTypeReference, pattern: ArrayBindingPattern) { const patternElements = pattern.elements; const arity = getTypeReferenceArity(type); - const elementTypes = arity ? type.typeArguments!.slice() : []; + const elementTypes = arity ? getTypeArguments(type).slice() : []; for (let i = arity; i < patternElements.length; i++) { const e = patternElements[i]; if (i < patternElements.length - 1 || !(e.kind === SyntaxKind.BindingElement && e.dotDotDotToken)) { @@ -26542,7 +26581,7 @@ namespace ts { } if (isReferenceToType(promise, getGlobalPromiseType(/*reportErrors*/ false))) { - return typeAsPromise.promisedTypeOfPromise = (promise).typeArguments![0]; + return typeAsPromise.promisedTypeOfPromise = getTypeArguments(promise)[0]; } const thenFunction = getTypeOfPropertyOfType(promise, "then" as __String)!; // TODO: GH#18217 @@ -28435,7 +28474,7 @@ namespace ts { let globalType: Type; if (isReferenceToType(type, globalType = resolver.getGlobalIterableType(/*reportErrors*/ false)) || isReferenceToType(type, globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false))) { - const [yieldType] = (type as GenericType).typeArguments!; + const [yieldType] = getTypeArguments(type as GenericType); // The "return" and "next" types of `Iterable` and `IterableIterator` are defined by the // iteration types of their `[Symbol.iterator]()` method. The same is true for their async cousins. // While we define these as `any` and `undefined` in our libs by default, a custom lib *could* use @@ -28448,7 +28487,7 @@ namespace ts { // just grab its related type arguments: // - `Generator` or `AsyncGenerator` if (isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))) { - const [yieldType, returnType, nextType] = (type as GenericType).typeArguments!; + const [yieldType, returnType, nextType] = getTypeArguments(type as GenericType); return (type as IterableOrIteratorType)[resolver.iterableCacheKey] = createIterationTypes(yieldType, returnType, nextType); } } @@ -28536,7 +28575,7 @@ namespace ts { // - `Generator` or `AsyncGenerator` const globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false); if (isReferenceToType(type, globalType)) { - const [yieldType] = (type as GenericType).typeArguments!; + const [yieldType] = getTypeArguments(type as GenericType); // The "return" and "next" types of `IterableIterator` and `AsyncIterableIterator` are defined by the // iteration types of their `next`, `return`, and `throw` methods. While we define these as `any` // and `undefined` in our libs by default, a custom lib *could* use different definitions. @@ -28548,7 +28587,7 @@ namespace ts { } if (isReferenceToType(type, resolver.getGlobalIteratorType(/*reportErrors*/ false)) || isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))) { - const [yieldType, returnType, nextType] = (type as GenericType).typeArguments!; + const [yieldType, returnType, nextType] = getTypeArguments(type as GenericType); return (type as IterableOrIteratorType)[resolver.iteratorCacheKey] = createIterationTypes(yieldType, returnType, nextType); } } @@ -28590,11 +28629,11 @@ namespace ts { // As an optimization, if the type is an instantiation of one of the global `IteratorYieldResult` // or `IteratorReturnResult` types, then just grab its type argument. if (isReferenceToType(type, getGlobalIteratorYieldResultType(/*reportErrors*/ false))) { - const yieldType = (type as GenericType).typeArguments![0]; + const yieldType = getTypeArguments(type as GenericType)[0]; return (type as IterableOrIteratorType).iterationTypesOfIteratorResult = createIterationTypes(yieldType, /*returnType*/ undefined, /*nextType*/ undefined); } if (isReferenceToType(type, getGlobalIteratorReturnResultType(/*reportErrors*/ false))) { - const returnType = (type as GenericType).typeArguments![0]; + const returnType = getTypeArguments(type as GenericType)[0]; return (type as IterableOrIteratorType).iterationTypesOfIteratorResult = createIterationTypes(/*yieldType*/ undefined, returnType, /*nextType*/ undefined); } diff --git a/src/compiler/symbolWalker.ts b/src/compiler/symbolWalker.ts index 1f6930076bef0..76bffca9740c8 100644 --- a/src/compiler/symbolWalker.ts +++ b/src/compiler/symbolWalker.ts @@ -10,7 +10,8 @@ namespace ts { getResolvedSymbol: (node: Node) => Symbol, getIndexTypeOfStructuredType: (type: Type, kind: IndexKind) => Type | undefined, getConstraintOfTypeParameter: (typeParameter: TypeParameter) => Type | undefined, - getFirstIdentifier: (node: EntityNameOrEntityNameExpression) => Identifier) { + getFirstIdentifier: (node: EntityNameOrEntityNameExpression) => Identifier, + getTypeArguments: (type: TypeReference) => ReadonlyArray) { return getSymbolWalker; @@ -89,7 +90,7 @@ namespace ts { function visitTypeReference(type: TypeReference): void { visitType(type.target); - forEach(type.typeArguments, visitType); + forEach(getTypeArguments(type), visitType); } function visitTypeParameter(type: TypeParameter): void { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index b3565e7797d21..f61aecbc9c3df 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -4200,7 +4200,9 @@ namespace ts { */ export interface TypeReference extends ObjectType { target: GenericType; // Type reference target - typeArguments?: ReadonlyArray; // Type reference type arguments (undefined if none) + resolvedTypeArguments?: ReadonlyArray; // Type reference type arguments (undefined if none) + typeArgumentNodes?: ReadonlyArray; + mapper?: TypeMapper; /* @internal */ literalType?: TypeReference; // Clone of type with ObjectFlags.ArrayLiteral set } From b24fcd0bc5cd76ca9fe82deac21495030689ba4d Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sat, 24 Aug 2019 08:54:59 -0400 Subject: [PATCH 02/25] Recursive tuple types + fix instantiation of recursive type references --- src/compiler/checker.ts | 69 ++++++++++++++++++++--------------------- 1 file changed, 33 insertions(+), 36 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b7e645e99d847..10761123a6baa 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9581,13 +9581,25 @@ namespace ts { return createTypeFromGenericGlobalType(readonly ? globalReadonlyArrayType : globalArrayType, [elementType]); } - function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type { + function getArrayOrTupleTargetType(node: ArrayTypeNode | TupleTypeNode): GenericType { + const readonly = isReadonlyTypeOperator(node.parent); + if (node.kind === SyntaxKind.ArrayType || node.elementTypes.length === 1 && node.elementTypes[0].kind === SyntaxKind.RestType) { + return readonly ? globalReadonlyArrayType : globalArrayType; + } + const lastElement = lastOrUndefined(node.elementTypes); + const restElement = lastElement && lastElement.kind === SyntaxKind.RestType ? lastElement : undefined; + const minLength = findLastIndex(node.elementTypes, n => n.kind !== SyntaxKind.OptionalType && n !== restElement) + 1; + return getTupleTypeOfArity(node.elementTypes.length, minLength, !!restElement, readonly, /*associatedNames*/ undefined); + } + + function getTypeFromArrayOrTupleTypeNode(node: ArrayTypeNode | TupleTypeNode): Type { const links = getNodeLinks(node); if (!links.resolvedType) { - const target = isReadonlyTypeOperator(node.parent) ? globalReadonlyArrayType : globalArrayType; + const target = getArrayOrTupleTargetType(node); const aliasSymbol = getAliasSymbolForTypeNode(node); const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); - links.resolvedType = createDeferredTypeReference(target, [node.elementType], /*mapper*/ undefined, aliasSymbol, aliasTypeArguments); + const elementTypes = node.kind === SyntaxKind.ArrayType ? [node.elementType] : node.elementTypes; + links.resolvedType = elementTypes.length ? createDeferredTypeReference(target, elementTypes, /*mapper*/ undefined, aliasSymbol, aliasTypeArguments) : target; } return links.resolvedType; } @@ -9665,21 +9677,6 @@ namespace ts { return elementTypes.length ? createTypeReference(tupleType, elementTypes) : tupleType; } - function getTypeFromTupleTypeNode(node: TupleTypeNode): Type { - const links = getNodeLinks(node); - if (!links.resolvedType) { - const lastElement = lastOrUndefined(node.elementTypes); - const restElement = lastElement && lastElement.kind === SyntaxKind.RestType ? lastElement : undefined; - const minLength = findLastIndex(node.elementTypes, n => n.kind !== SyntaxKind.OptionalType && n !== restElement) + 1; - const elementTypes = map(node.elementTypes, n => { - const type = getTypeFromTypeNode(n); - return n === restElement && getIndexTypeOfType(type, IndexKind.Number) || type; - }); - links.resolvedType = createTupleType(elementTypes, minLength, !!restElement, isReadonlyTypeOperator(node.parent)); - } - return links.resolvedType; - } - function sliceTupleType(type: TupleTypeReference, index: number) { const tuple = type.target; if (tuple.hasRestElement) { @@ -11169,9 +11166,8 @@ namespace ts { case SyntaxKind.TypeQuery: return getTypeFromTypeQueryNode(node); case SyntaxKind.ArrayType: - return getTypeFromArrayTypeNode(node); case SyntaxKind.TupleType: - return getTypeFromTupleTypeNode(node); + return getTypeFromArrayOrTupleTypeNode(node); case SyntaxKind.OptionalType: return getTypeFromOptionalTypeNode(node); case SyntaxKind.UnionType: @@ -11183,10 +11179,11 @@ namespace ts { case SyntaxKind.JSDocOptionalType: return addOptionality(getTypeFromTypeNode((node as JSDocOptionalType).type)); case SyntaxKind.ParenthesizedType: - case SyntaxKind.RestType: case SyntaxKind.JSDocNonNullableType: case SyntaxKind.JSDocTypeExpression: - return getTypeFromTypeNode((node).type); + return getTypeFromTypeNode((node).type); + case SyntaxKind.RestType: + return getElementTypeOfArrayType(getTypeFromTypeNode((node).type)) || errorType; case SyntaxKind.JSDocVariadicType: return getTypeFromJSDocVariadicType(node as JSDocVariadicType); case SyntaxKind.FunctionType: @@ -11644,19 +11641,15 @@ namespace ts { return getAnonymousTypeInstantiation(type, mapper); } if (objectFlags & ObjectFlags.Reference) { - const resolvedTypeArguments = (type).resolvedTypeArguments; - if (resolvedTypeArguments) { - const newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper); - return newTypeArguments !== resolvedTypeArguments ? createTypeReference((type).target, newTypeArguments) : type; - } - else { - const typeArgumentNodes = (type).typeArgumentNodes; - if (typeArgumentNodes) { - const combinedMapper = combineTypeMappers((type).mapper, mapper); - return createDeferredTypeReference((type).target, typeArgumentNodes, combinedMapper, - (type).aliasSymbol, instantiateTypes((type).aliasTypeArguments, combinedMapper)); - } + const typeArgumentNodes = (type).typeArgumentNodes; + if (typeArgumentNodes) { + const combinedMapper = combineTypeMappers((type).mapper, mapper); + return createDeferredTypeReference((type).target, typeArgumentNodes, combinedMapper, + (type).aliasSymbol, instantiateTypes((type).aliasTypeArguments, combinedMapper)); } + const resolvedTypeArguments = (type).resolvedTypeArguments; + const newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper); + return newTypeArguments !== resolvedTypeArguments ? createTypeReference((type).target, newTypeArguments) : type; } return type; } @@ -14446,8 +14439,12 @@ namespace ts { return type.flags & TypeFlags.TypeParameter && !getConstraintOfTypeParameter(type); } + function isNonDeferredTypeReference(type: Type): type is TypeReference { + return !!(getObjectFlags(type) & ObjectFlags.Reference) && !(type).typeArgumentNodes; + } + function isTypeReferenceWithGenericArguments(type: Type): boolean { - return !!(getObjectFlags(type) & ObjectFlags.Reference) && some(getTypeArguments(type), t => isUnconstrainedTypeParameter(t) || isTypeReferenceWithGenericArguments(t)); + return isNonDeferredTypeReference(type) && some(getTypeArguments(type), t => isUnconstrainedTypeParameter(t) || isTypeReferenceWithGenericArguments(t)); } /** @@ -26090,7 +26087,7 @@ namespace ts { grammarErrorOnNode(e, Diagnostics.A_rest_element_must_be_last_in_a_tuple_type); break; } - if (!isArrayType(getTypeFromTypeNode(e))) { + if (!isArrayType(getTypeFromTypeNode((e).type))) { error(e, Diagnostics.A_rest_element_type_must_be_an_array_type); } } From 52a1a14331e6938226ca61c9ccb3ea7e115c2956 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 26 Aug 2019 07:08:37 -0400 Subject: [PATCH 03/25] Instantiate deferred type references like anonymous types --- src/compiler/checker.ts | 48 +++++++++++++++++++++-------------------- src/compiler/types.ts | 11 ++++++++-- 2 files changed, 34 insertions(+), 25 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 10761123a6baa..b752f8fa5ff1e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9077,10 +9077,10 @@ namespace ts { return type; } - function createDeferredTypeReference(target: GenericType, typeArgumentNodes: ReadonlyArray, mapper?: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: ReadonlyArray): TypeReference { - const type = createObjectType(ObjectFlags.Reference, target.symbol); + function createDeferredTypeReference(target: GenericType, node: ArrayTypeNode | TupleTypeNode, mapper?: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: ReadonlyArray): DeferredTypeReference { + const type = createObjectType(ObjectFlags.Reference, target.symbol); type.target = target; - type.typeArgumentNodes = typeArgumentNodes; + type.node = node; type.mapper = mapper; type.aliasSymbol = aliasSymbol; type.aliasTypeArguments = aliasTypeArguments; @@ -9089,7 +9089,7 @@ namespace ts { function getTypeArguments(type: TypeReference): ReadonlyArray { if (!type.resolvedTypeArguments) { - const typeArguments = type.typeArgumentNodes ? map(type.typeArgumentNodes, getTypeFromTypeNode) : emptyArray; + const typeArguments = type.node ? map(type.node.kind === SyntaxKind.ArrayType ? [type.node.elementType] : type.node.elementTypes, getTypeFromTypeNode) : emptyArray; type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments; } return type.resolvedTypeArguments; @@ -9598,8 +9598,8 @@ namespace ts { const target = getArrayOrTupleTargetType(node); const aliasSymbol = getAliasSymbolForTypeNode(node); const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); - const elementTypes = node.kind === SyntaxKind.ArrayType ? [node.elementType] : node.elementTypes; - links.resolvedType = elementTypes.length ? createDeferredTypeReference(target, elementTypes, /*mapper*/ undefined, aliasSymbol, aliasTypeArguments) : target; + links.resolvedType = node.kind === SyntaxKind.TupleType && node.elementTypes.length === 0 ? target : + createDeferredTypeReference(target, node, /*mapper*/ undefined, aliasSymbol, aliasTypeArguments); } return links.resolvedType; } @@ -11393,17 +11393,17 @@ namespace ts { return result; } - function getAnonymousTypeInstantiation(type: AnonymousType, mapper: TypeMapper) { + function getObjectTypeInstantiation(type: AnonymousType | DeferredTypeReference, mapper: TypeMapper) { const target = type.objectFlags & ObjectFlags.Instantiated ? type.target! : type; - const { symbol } = target; - const links = getSymbolLinks(symbol); + const node = type.objectFlags & ObjectFlags.Reference ? (type).node! : type.symbol.declarations[0]; + const links = getNodeLinks(node); let typeParameters = links.outerTypeParameters; if (!typeParameters) { // The first time an anonymous type is instantiated we compute and store a list of the type // parameters that are in scope (and therefore potentially referenced). For type literals that // aren't the right hand side of a generic type alias declaration we optimize by reducing the // set of type parameters to those that are possibly referenced in the literal. - let declaration = symbol.declarations[0]; + let declaration = node; if (isInJSFile(declaration)) { const paramTag = findAncestor(declaration, isJSDocParameterTag); if (paramTag) { @@ -11419,7 +11419,7 @@ namespace ts { outerTypeParameters = addRange(outerTypeParameters, templateTagParameters); } typeParameters = outerTypeParameters || emptyArray; - typeParameters = symbol.flags & SymbolFlags.TypeLiteral && !target.aliasTypeArguments ? + typeParameters = (target.objectFlags & ObjectFlags.Reference || target.symbol.flags & SymbolFlags.TypeLiteral) && !target.aliasTypeArguments ? filter(typeParameters, tp => isTypeParameterPossiblyReferenced(tp, declaration)) : typeParameters; links.outerTypeParameters = typeParameters; @@ -11432,13 +11432,14 @@ namespace ts { // We are instantiating an anonymous type that has one or more type parameters in scope. Apply the // mapper to the type parameters to produce the effective list of type arguments, and compute the // instantiation cache key from the type IDs of the type arguments. - const combinedMapper = type.objectFlags & ObjectFlags.Instantiated ? combineTypeMappers(type.mapper!, mapper) : mapper; - const typeArguments: Type[] = map(typeParameters, combinedMapper); + const typeArguments: Type[] = map(typeParameters, combineTypeMappers(type.mapper, mapper)); const id = getTypeListId(typeArguments); let result = links.instantiations!.get(id); if (!result) { const newMapper = createTypeMapper(typeParameters, typeArguments); - result = target.objectFlags & ObjectFlags.Mapped ? instantiateMappedType(target, newMapper) : instantiateAnonymousType(target, newMapper); + result = target.objectFlags & ObjectFlags.Reference ? instantiateDeferredTypeReference(type, newMapper) : + target.objectFlags & ObjectFlags.Mapped ? instantiateMappedType(target, newMapper) : + instantiateAnonymousType(target, newMapper); links.instantiations!.set(id, result); } return result; @@ -11570,6 +11571,10 @@ namespace ts { return result; } + function instantiateDeferredTypeReference(type: DeferredTypeReference, mapper: TypeMapper): TypeReference { + return createDeferredTypeReference(type.target, type.node, mapper, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)); + } + function getConditionalTypeInstantiation(type: ConditionalType, mapper: TypeMapper): Type { const root = type.root; if (root.outerTypeParameters) { @@ -11635,17 +11640,14 @@ namespace ts { // interface, in an object type literal, or in an object literal expression, we may need // to instantiate the type because it might reference a type parameter. return couldContainTypeVariables(type) ? - getAnonymousTypeInstantiation(type, mapper) : type; + getObjectTypeInstantiation(type, mapper) : type; } if (objectFlags & ObjectFlags.Mapped) { - return getAnonymousTypeInstantiation(type, mapper); + return getObjectTypeInstantiation(type, mapper); } if (objectFlags & ObjectFlags.Reference) { - const typeArgumentNodes = (type).typeArgumentNodes; - if (typeArgumentNodes) { - const combinedMapper = combineTypeMappers((type).mapper, mapper); - return createDeferredTypeReference((type).target, typeArgumentNodes, combinedMapper, - (type).aliasSymbol, instantiateTypes((type).aliasTypeArguments, combinedMapper)); + if ((type).node) { + return getObjectTypeInstantiation(type, mapper); } const resolvedTypeArguments = (type).resolvedTypeArguments; const newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper); @@ -14440,7 +14442,7 @@ namespace ts { } function isNonDeferredTypeReference(type: Type): type is TypeReference { - return !!(getObjectFlags(type) & ObjectFlags.Reference) && !(type).typeArgumentNodes; + return !!(getObjectFlags(type) & ObjectFlags.Reference) && !(type).node; } function isTypeReferenceWithGenericArguments(type: Type): boolean { @@ -22849,7 +22851,7 @@ namespace ts { * Indicates whether a declaration can be treated as a constructor in a JavaScript * file. */ - function isJSConstructor(node: Declaration | undefined): boolean { + function isJSConstructor(node: Node | undefined): boolean { if (!node || !isInJSFile(node)) { return false; } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index f61aecbc9c3df..1b8c8df94e28f 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -3954,6 +3954,8 @@ namespace ts { contextFreeType?: Type; // Cached context-free type used by the first pass of inference; used when a function's return is partially contextually sensitive deferredNodes?: Map; // Set of nodes whose checking has been deferred capturedBlockScopeBindings?: Symbol[]; // Block-scoped bindings captured beneath this part of an IterationStatement + outerTypeParameters?: TypeParameter[]; // Outer type parameters of anonymous object type + instantiations?: Map; // Instantiations of generic type alias (undefined if non-generic) } export const enum TypeFlags { @@ -4200,13 +4202,18 @@ namespace ts { */ export interface TypeReference extends ObjectType { target: GenericType; // Type reference target - resolvedTypeArguments?: ReadonlyArray; // Type reference type arguments (undefined if none) - typeArgumentNodes?: ReadonlyArray; + node?: ArrayTypeNode | TupleTypeNode; mapper?: TypeMapper; + resolvedTypeArguments?: ReadonlyArray; // Resolved ype reference type arguments /* @internal */ literalType?: TypeReference; // Clone of type with ObjectFlags.ArrayLiteral set } + export interface DeferredTypeReference extends TypeReference { + node: ArrayTypeNode | TupleTypeNode; + mapper?: TypeMapper; + } + /* @internal */ export const enum VarianceFlags { Invariant = 0, // Neither covariant nor contravariant From dd47fffe8fefed52d9d1d62fb4ba32c7f7bd651c Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 26 Aug 2019 11:00:20 -0400 Subject: [PATCH 04/25] Properly handle recursive array and tuple types in printback --- src/compiler/checker.ts | 68 ++++++++++++++++++++++------------------- 1 file changed, 36 insertions(+), 32 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b752f8fa5ff1e..81eda207fc3f5 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3540,7 +3540,6 @@ namespace ts { } function createNodeBuilder() { - let depth = 0; return { typeToTypeNode: (type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => typeToTypeNodeHelper(type, context)), @@ -3712,7 +3711,7 @@ namespace ts { if (objectFlags & ObjectFlags.Reference) { Debug.assert(!!(type.flags & TypeFlags.Object)); - return typeReferenceToTypeNode(type); + return (type).node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type); } if (type.flags & TypeFlags.TypeParameter || objectFlags & ObjectFlags.ClassOrInterface) { if (type.flags & TypeFlags.TypeParameter && contains(context.inferTypeParameters, type)) { @@ -3804,10 +3803,7 @@ namespace ts { function createAnonymousTypeNode(type: ObjectType): TypeNode { const typeId = "" + type.id; const symbol = type.symbol; - let id: string; if (symbol) { - const isConstructorObject = getObjectFlags(type) & ObjectFlags.Anonymous && type.symbol && type.symbol.flags & SymbolFlags.Class; - id = (isConstructorObject ? "+" : "") + getSymbolId(symbol); if (isJSConstructor(symbol.valueDeclaration)) { // Instance and static types share the same symbol; only add 'typeof' for the static side. const isInstanceType = type === getInferredClassType(symbol) ? SymbolFlags.Type : SymbolFlags.Value; @@ -3831,25 +3827,7 @@ namespace ts { } } else { - // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead - // of types allows us to catch circular references to instantiations of the same anonymous type - if (!context.visitedTypes) { - context.visitedTypes = createMap(); - } - if (!context.symbolDepth) { - context.symbolDepth = createMap(); - } - - const depth = context.symbolDepth.get(id) || 0; - if (depth > 10) { - return createElidedInformationPlaceholder(context); - } - context.symbolDepth.set(id, depth + 1); - context.visitedTypes.set(typeId, true); - const result = createTypeNodeFromObjectType(type); - context.visitedTypes.delete(typeId); - context.symbolDepth.set(id, depth); - return result; + return visitAndTransformType(type, createTypeNodeFromObjectType); } } else { @@ -3871,6 +3849,37 @@ namespace ts { } } + function visitAndTransformType(type: Type, transform: (type: Type) => T) { + const typeId = "" + type.id; + const isConstructorObject = getObjectFlags(type) & ObjectFlags.Anonymous && type.symbol && type.symbol.flags & SymbolFlags.Class; + const id = getObjectFlags(type) & ObjectFlags.Reference ? "N" + getNodeId((type).node) : + (isConstructorObject ? "+" : "") + getSymbolId(type.symbol); + // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead + // of types allows us to catch circular references to instantiations of the same anonymous type + if (!context.visitedTypes) { + context.visitedTypes = createMap(); + } + if (id && !context.symbolDepth) { + context.symbolDepth = createMap(); + } + + let depth: number | undefined; + if (id) { + depth = context.symbolDepth!.get(id) || 0; + if (depth > 10) { + return createElidedInformationPlaceholder(context); + } + context.symbolDepth!.set(id, depth + 1); + } + context.visitedTypes.set(typeId, true); + const result = transform(type); + context.visitedTypes.delete(typeId); + if (id) { + context.symbolDepth!.set(id, depth!); + } + return result; + } + function createTypeNodeFromObjectType(type: ObjectType): TypeNode { if (isGenericMappedType(type)) { return createMappedTypeNodeFromType(type); @@ -3910,15 +3919,10 @@ namespace ts { const typeArguments: ReadonlyArray = getTypeArguments(type); if (type.target === globalArrayType || type.target === globalReadonlyArrayType) { if (context.flags & NodeBuilderFlags.WriteArrayAsGenericType) { - depth++; - const typeArgumentNode = typeToTypeNodeHelper(depth >= 5 ? anyType : typeArguments[0], context); - depth--; - createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]); + const typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context); + return createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]); } - - depth++; - const elementType = typeToTypeNodeHelper(depth >= 5 ? anyType : typeArguments[0], context); - depth--; + const elementType = typeToTypeNodeHelper(typeArguments[0], context); const arrayType = createArrayTypeNode(elementType); return type.target === globalArrayType ? arrayType : createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, arrayType); } From 5310fd0156f6714506c1b6b7892d21177e30a898 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 27 Aug 2019 06:51:21 -0400 Subject: [PATCH 05/25] Minor fixes --- src/compiler/checker.ts | 12 +++++------- src/compiler/types.ts | 4 ++++ 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 13dbc1c7886ab..e49e449226563 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3876,8 +3876,9 @@ namespace ts { function visitAndTransformType(type: Type, transform: (type: Type) => T) { const typeId = "" + type.id; const isConstructorObject = getObjectFlags(type) & ObjectFlags.Anonymous && type.symbol && type.symbol.flags & SymbolFlags.Class; - const id = getObjectFlags(type) & ObjectFlags.Reference ? "N" + getNodeId((type).node) : - (isConstructorObject ? "+" : "") + getSymbolId(type.symbol); + const id = getObjectFlags(type) & ObjectFlags.Reference && (type).node ? "N" + getNodeId((type).node!) : + type.symbol ? (isConstructorObject ? "+" : "") + getSymbolId(type.symbol) : + undefined; // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead // of types allows us to catch circular references to instantiations of the same anonymous type if (!context.visitedTypes) { @@ -29347,12 +29348,9 @@ namespace ts { if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class) && !(baseConstructorType.flags & TypeFlags.TypeVariable)) { // When the static base type is a "class-like" constructor function (but not actually a class), we verify - // that all instantiated base constructor signatures return the same type. We can simply compare the type - // references (as opposed to checking the structure of the types) because elsewhere we have already checked - // that the base type is a class or interface type (and not, for example, an anonymous object type). - // (Javascript constructor functions have this property trivially true since their return type is ignored.) + // that all instantiated base constructor signatures return the same type. const constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); - if (forEach(constructors, sig => !isJSConstructor(sig.declaration) && getReturnTypeOfSignature(sig) !== baseType)) { + if (forEach(constructors, sig => !isJSConstructor(sig.declaration) && !isTypeIdenticalTo(getReturnTypeOfSignature(sig), baseType))) { error(baseTypeNode.expression, Diagnostics.Base_constructors_must_all_have_the_same_return_type); } } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index ce4c6a90819e1..21f09ffcd5c38 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -4203,14 +4203,18 @@ namespace ts { export interface TypeReference extends ObjectType { target: GenericType; // Type reference target node?: ArrayTypeNode | TupleTypeNode; + /* @internal */ mapper?: TypeMapper; + /* @internal */ resolvedTypeArguments?: ReadonlyArray; // Resolved ype reference type arguments /* @internal */ literalType?: TypeReference; // Clone of type with ObjectFlags.ArrayLiteral set } export interface DeferredTypeReference extends TypeReference { + /* @internal */ node: ArrayTypeNode | TupleTypeNode; + /* @internal */ mapper?: TypeMapper; } From 5c21f4312154a5fa9a09c98ec621ce01fbafba08 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 27 Aug 2019 06:51:47 -0400 Subject: [PATCH 06/25] Accept new baselines --- .../reference/api/tsserverlibrary.d.ts | 4 +- tests/baselines/reference/api/typescript.d.ts | 4 +- .../baselines/reference/arrayFrom.errors.txt | 2 + .../reference/castingTuple.errors.txt | 2 + .../reference/checkJsxChildrenProperty3.types | 4 +- .../checkJsxChildrenProperty4.errors.txt | 16 +- .../reference/checkJsxChildrenProperty4.types | 4 +- .../complexRecursiveCollections.types | 16 +- .../reference/conditionalTypes1.types | 2 +- .../contextualSignatureInstantiation.types | 2 +- .../contextualTypingOfOptionalMembers.types | 14 +- ...EmitDestructuringParameterProperties.types | 2 +- .../reference/destructuringControlFlow.types | 2 +- .../destructuringInFunctionType.types | 6 +- .../destructuringParameterProperties1.types | 2 +- .../destructuringParameterProperties5.types | 2 +- ...ectDependenceBetweenTypeAliases.errors.txt | 29 +--- .../directDependenceBetweenTypeAliases.types | 34 ++--- ...cessPrivateMemberOfGenericConstraint.types | 2 +- tests/baselines/reference/inferTypes1.types | 12 +- .../interfaceExtendsObjectIntersection.types | 4 +- ...rfaceExtendsObjectIntersectionErrors.types | 4 +- .../intersectionTypeWithLeadingOperator.types | 2 +- ...onfusableWithMultipleChildrenNoError.types | 4 +- .../reference/mapOnTupleTypes02.types | 8 +- .../optionalTupleElements1.errors.txt | 24 +-- .../reference/optionalTupleElements1.types | 140 +++++++++--------- .../reference/readonlyArraysAndTuples.types | 4 +- .../reference/readonlyArraysAndTuples2.types | 4 +- .../reference/recursiveMappedTypes.types | 8 +- .../recursiveResolveTypeMembers.errors.txt | 4 +- .../recursiveTypesWithTypeof.errors.txt | 7 +- .../reference/recursiveTypesWithTypeof.types | 6 +- .../reference/restTupleElements1.types | 40 ++--- ...nDestructuringForArrayBindingPattern.types | 66 ++++----- ...DestructuringForArrayBindingPattern2.types | 106 ++++++------- ...gForArrayBindingPatternDefaultValues.types | 60 ++++---- ...ForArrayBindingPatternDefaultValues2.types | 90 +++++------ ...estructuringForOfArrayBindingPattern.types | 132 ++++++++--------- ...structuringForOfArrayBindingPattern2.types | 132 ++++++++--------- ...orOfArrayBindingPatternDefaultValues.types | 120 +++++++-------- ...rOfArrayBindingPatternDefaultValues2.types | 120 +++++++-------- ...cturingParametertArrayBindingPattern.types | 36 ++--- ...turingParametertArrayBindingPattern2.types | 36 ++--- ...tertArrayBindingPatternDefaultValues.types | 36 ++--- ...ertArrayBindingPatternDefaultValues2.types | 28 ++-- ...VariableStatementArrayBindingPattern.types | 14 +- ...ariableStatementArrayBindingPattern2.types | 14 +- ...ariableStatementArrayBindingPattern3.types | 104 ++++++------- ...mentArrayBindingPatternDefaultValues.types | 14 +- ...entArrayBindingPatternDefaultValues2.types | 12 +- ...entArrayBindingPatternDefaultValues3.types | 94 ++++++------ .../reference/specedNoStackBlown.types | 4 +- .../spreadBooleanRespectsFreshness.types | 6 +- .../reference/spreadTypeVariable.types | 2 +- .../baselines/reference/tupleTypes.errors.txt | 4 +- tests/baselines/reference/typeAliases.types | 12 +- ...dNarrowsIndexedAccessOfKnownProperty.types | 8 +- .../reference/typeInferenceLiteralUnion.types | 4 +- .../typePredicateStructuralMatch.types | 54 +++---- .../unionTypeWithLeadingOperator.types | 2 +- .../reference/unionsOfTupleTypes1.errors.txt | 16 +- .../reference/unionsOfTupleTypes1.types | 42 +++--- 63 files changed, 885 insertions(+), 903 deletions(-) diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index bffe2114d19b5..c70f389e21073 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -2351,7 +2351,9 @@ declare namespace ts { */ export interface TypeReference extends ObjectType { target: GenericType; - typeArguments?: ReadonlyArray; + node?: ArrayTypeNode | TupleTypeNode; + } + export interface DeferredTypeReference extends TypeReference { } export interface GenericType extends InterfaceType, TypeReference { } diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 457a1acb227aa..c7b96ded9b289 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -2351,7 +2351,9 @@ declare namespace ts { */ export interface TypeReference extends ObjectType { target: GenericType; - typeArguments?: ReadonlyArray; + node?: ArrayTypeNode | TupleTypeNode; + } + export interface DeferredTypeReference extends TypeReference { } export interface GenericType extends InterfaceType, TypeReference { } diff --git a/tests/baselines/reference/arrayFrom.errors.txt b/tests/baselines/reference/arrayFrom.errors.txt index 615bd1bf76955..7d9645f94208c 100644 --- a/tests/baselines/reference/arrayFrom.errors.txt +++ b/tests/baselines/reference/arrayFrom.errors.txt @@ -1,6 +1,7 @@ tests/cases/compiler/arrayFrom.ts(20,7): error TS2322: Type 'A[]' is not assignable to type 'B[]'. Property 'b' is missing in type 'A' but required in type 'B'. tests/cases/compiler/arrayFrom.ts(23,7): error TS2322: Type 'A[]' is not assignable to type 'B[]'. + Type 'A' is not assignable to type 'B'. ==== tests/cases/compiler/arrayFrom.ts (2 errors) ==== @@ -33,6 +34,7 @@ tests/cases/compiler/arrayFrom.ts(23,7): error TS2322: Type 'A[]' is not assigna const result6: B[] = Array.from(inputALike); // expect error ~~~~~~~ !!! error TS2322: Type 'A[]' is not assignable to type 'B[]'. +!!! error TS2322: Type 'A' is not assignable to type 'B'. const result7: B[] = Array.from(inputALike, ({ a }): B => ({ b: a })); const result8: A[] = Array.from(inputARand); const result9: B[] = Array.from(inputARand, ({ a }): B => ({ b: a })); diff --git a/tests/baselines/reference/castingTuple.errors.txt b/tests/baselines/reference/castingTuple.errors.txt index 0a1d592e8b1cf..56941dfddd0a6 100644 --- a/tests/baselines/reference/castingTuple.errors.txt +++ b/tests/baselines/reference/castingTuple.errors.txt @@ -4,6 +4,7 @@ tests/cases/conformance/types/tuple/castingTuple.ts(14,15): error TS2352: Conver Types of property 'length' are incompatible. Type '3' is not comparable to type '2'. tests/cases/conformance/types/tuple/castingTuple.ts(15,14): error TS2352: Conversion of type '[number, string]' to type '[number, string, boolean]' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. + Property '2' is missing in type '[number, string]' but required in type '[number, string, boolean]'. tests/cases/conformance/types/tuple/castingTuple.ts(18,21): error TS2352: Conversion of type '[C, D]' to type '[C, D, A]' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. Property '2' is missing in type '[C, D]' but required in type '[C, D, A]'. tests/cases/conformance/types/tuple/castingTuple.ts(20,33): error TS2493: Tuple type '[C, D, A]' of length '3' has no element at index '5'. @@ -40,6 +41,7 @@ tests/cases/conformance/types/tuple/castingTuple.ts(33,1): error TS2304: Cannot var longer = numStrTuple as [number, string, boolean] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2352: Conversion of type '[number, string]' to type '[number, string, boolean]' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. +!!! error TS2352: Property '2' is missing in type '[number, string]' but required in type '[number, string, boolean]'. var classCDTuple: [C, D] = [new C(), new D()]; var interfaceIITuple = <[I, I]>classCDTuple; var classCDATuple = <[C, D, A]>classCDTuple; diff --git a/tests/baselines/reference/checkJsxChildrenProperty3.types b/tests/baselines/reference/checkJsxChildrenProperty3.types index f2ed3dc8fd00a..2d4380a197531 100644 --- a/tests/baselines/reference/checkJsxChildrenProperty3.types +++ b/tests/baselines/reference/checkJsxChildrenProperty3.types @@ -31,11 +31,11 @@ class FetchUser extends React.Component { ? this.props.children(this.state.result) >this.props.children(this.state.result) : JSX.Element ->this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) +>this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement | any[])[]) >this.props : IFetchUserProps & { children?: React.ReactNode; } >this : this >props : IFetchUserProps & { children?: React.ReactNode; } ->children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) +>children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement | any[])[]) >this.state.result : any >this.state : any >this : this diff --git a/tests/baselines/reference/checkJsxChildrenProperty4.errors.txt b/tests/baselines/reference/checkJsxChildrenProperty4.errors.txt index 34bd218996483..40eb1d77677f5 100644 --- a/tests/baselines/reference/checkJsxChildrenProperty4.errors.txt +++ b/tests/baselines/reference/checkJsxChildrenProperty4.errors.txt @@ -1,8 +1,8 @@ tests/cases/conformance/jsx/file.tsx(24,28): error TS2551: Property 'NAme' does not exist on type 'IUser'. Did you mean 'Name'? -tests/cases/conformance/jsx/file.tsx(36,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement'. - Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement': type, props -tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement'. - Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement': type, props +tests/cases/conformance/jsx/file.tsx(36,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement | any[]'. + Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more. +tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement | any[]'. + Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more. ==== tests/cases/conformance/jsx/file.tsx (3 errors) ==== @@ -50,8 +50,8 @@ tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) = ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ) } ~~~~~~~~~~~~~ -!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement'. -!!! error TS2322: Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement': type, props +!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement | any[]'. +!!! error TS2322: Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more. !!! related TS6212 tests/cases/conformance/jsx/file.tsx:36:15: Did you mean to call this expression? { user => ( ~~~~~~~~~ @@ -59,8 +59,8 @@ tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) = ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ) } ~~~~~~~~~~~~~ -!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement'. -!!! error TS2322: Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement': type, props +!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement | any[]'. +!!! error TS2322: Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more. !!! related TS6212 tests/cases/conformance/jsx/file.tsx:39:15: Did you mean to call this expression? ); diff --git a/tests/baselines/reference/checkJsxChildrenProperty4.types b/tests/baselines/reference/checkJsxChildrenProperty4.types index 067e8f2611af6..4f753cf9f3b03 100644 --- a/tests/baselines/reference/checkJsxChildrenProperty4.types +++ b/tests/baselines/reference/checkJsxChildrenProperty4.types @@ -31,11 +31,11 @@ class FetchUser extends React.Component { ? this.props.children(this.state.result) >this.props.children(this.state.result) : JSX.Element ->this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) +>this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement | any[])[]) >this.props : IFetchUserProps & { children?: React.ReactNode; } >this : this >props : IFetchUserProps & { children?: React.ReactNode; } ->children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) +>children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement | any[])[]) >this.state.result : any >this.state : any >this : this diff --git a/tests/baselines/reference/complexRecursiveCollections.types b/tests/baselines/reference/complexRecursiveCollections.types index feaff62048628..2450407e90d3c 100644 --- a/tests/baselines/reference/complexRecursiveCollections.types +++ b/tests/baselines/reference/complexRecursiveCollections.types @@ -1029,28 +1029,28 @@ declare module Immutable { >value : T[K] merge(...collections: Array | Iterable<[string, any]>>): this; ->merge : (...collections: (Iterable<[string, any]> | Partial)[]) => this ->collections : (Iterable<[string, any]> | Partial)[] +>merge : (...collections: (Partial | Iterable<[string, any]>)[]) => this +>collections : (Partial | Iterable<[string, any]>)[] mergeDeep(...collections: Array | Iterable<[string, any]>>): this; ->mergeDeep : (...collections: (Iterable<[string, any]> | Partial)[]) => this ->collections : (Iterable<[string, any]> | Partial)[] +>mergeDeep : (...collections: (Partial | Iterable<[string, any]>)[]) => this +>collections : (Partial | Iterable<[string, any]>)[] mergeWith(merger: (oldVal: any, newVal: any, key: keyof T) => any, ...collections: Array | Iterable<[string, any]>>): this; ->mergeWith : (merger: (oldVal: any, newVal: any, key: keyof T) => any, ...collections: (Iterable<[string, any]> | Partial)[]) => this +>mergeWith : (merger: (oldVal: any, newVal: any, key: keyof T) => any, ...collections: (Partial | Iterable<[string, any]>)[]) => this >merger : (oldVal: any, newVal: any, key: keyof T) => any >oldVal : any >newVal : any >key : keyof T ->collections : (Iterable<[string, any]> | Partial)[] +>collections : (Partial | Iterable<[string, any]>)[] mergeDeepWith(merger: (oldVal: any, newVal: any, key: any) => any, ...collections: Array | Iterable<[string, any]>>): this; ->mergeDeepWith : (merger: (oldVal: any, newVal: any, key: any) => any, ...collections: (Iterable<[string, any]> | Partial)[]) => this +>mergeDeepWith : (merger: (oldVal: any, newVal: any, key: any) => any, ...collections: (Partial | Iterable<[string, any]>)[]) => this >merger : (oldVal: any, newVal: any, key: any) => any >oldVal : any >newVal : any >key : any ->collections : (Iterable<[string, any]> | Partial)[] +>collections : (Partial | Iterable<[string, any]>)[] delete(key: K): this; >delete : (key: K) => this diff --git a/tests/baselines/reference/conditionalTypes1.types b/tests/baselines/reference/conditionalTypes1.types index 234fc071d7433..2d5af28ca5e07 100644 --- a/tests/baselines/reference/conditionalTypes1.types +++ b/tests/baselines/reference/conditionalTypes1.types @@ -494,7 +494,7 @@ function f21(x: T, y: ZeroOf) { } type T35 = T[]; ->T35 : T[] +>T35 : T35 >a : string >b : number diff --git a/tests/baselines/reference/contextualSignatureInstantiation.types b/tests/baselines/reference/contextualSignatureInstantiation.types index ae5a40005377e..57e8f79a28f39 100644 --- a/tests/baselines/reference/contextualSignatureInstantiation.types +++ b/tests/baselines/reference/contextualSignatureInstantiation.types @@ -108,7 +108,7 @@ var d = bar(1, "one", h); // Should be number[] | string[] var d = bar("one", 1, h); // Should be number[] | string[] >d : number[] | string[] ->bar("one", 1, h) : number[] | string[] +>bar("one", 1, h) : string[] | number[] >bar : (x: T, y: U, cb: (x: T, y: U) => V) => V >"one" : "one" >1 : 1 diff --git a/tests/baselines/reference/contextualTypingOfOptionalMembers.types b/tests/baselines/reference/contextualTypingOfOptionalMembers.types index f4a9e23190d9d..9df692608c2cd 100644 --- a/tests/baselines/reference/contextualTypingOfOptionalMembers.types +++ b/tests/baselines/reference/contextualTypingOfOptionalMembers.types @@ -124,17 +124,17 @@ app2({ type ActionsArray = ((state: State) => State)[]; ->ActionsArray : ((state: State) => State)[] +>ActionsArray : ActionsArray >state : State declare function app3>(obj: Options): void; ->app3 : State)[]>(obj: Options) => void +>app3 : >(obj: Options) => void >obj : Options app3({ >app3({ state: 100, actions: [ s => s // Should be typed number => number ], view: (s, a) => undefined as any,}) : void ->app3 : State)[]>(obj: Options) => void ->{ state: 100, actions: [ s => s // Should be typed number => number ], view: (s, a) => undefined as any,} : { state: number; actions: ((s: number) => number)[]; view: (s: number, a: ((state: number) => number)[]) => any; } +>app3 : >(obj: Options) => void +>{ state: 100, actions: [ s => s // Should be typed number => number ], view: (s, a) => undefined as any,} : { state: number; actions: ((s: number) => number)[]; view: (s: number, a: ActionsArray) => any; } state: 100, >state : number @@ -151,10 +151,10 @@ app3({ ], view: (s, a) => undefined as any, ->view : (s: number, a: ((state: number) => number)[]) => any ->(s, a) => undefined as any : (s: number, a: ((state: number) => number)[]) => any +>view : (s: number, a: ActionsArray) => any +>(s, a) => undefined as any : (s: number, a: ActionsArray) => any >s : number ->a : ((state: number) => number)[] +>a : ActionsArray >undefined as any : any >undefined : undefined diff --git a/tests/baselines/reference/declarationEmitDestructuringParameterProperties.types b/tests/baselines/reference/declarationEmitDestructuringParameterProperties.types index b7407b0232fca..d76fd67f9d65a 100644 --- a/tests/baselines/reference/declarationEmitDestructuringParameterProperties.types +++ b/tests/baselines/reference/declarationEmitDestructuringParameterProperties.types @@ -10,7 +10,7 @@ class C1 { } type TupleType1 =[string, number, boolean]; ->TupleType1 : [string, number, boolean] +>TupleType1 : TupleType1 class C2 { >C2 : C2 diff --git a/tests/baselines/reference/destructuringControlFlow.types b/tests/baselines/reference/destructuringControlFlow.types index 347aae32c10b1..b6b9967ba43d0 100644 --- a/tests/baselines/reference/destructuringControlFlow.types +++ b/tests/baselines/reference/destructuringControlFlow.types @@ -161,7 +161,7 @@ function f4() { // Repro from #31770 type KeyValue = [string, string?]; ->KeyValue : [string, (string | undefined)?] +>KeyValue : KeyValue let [key, value]: KeyValue = ["foo"]; >key : string diff --git a/tests/baselines/reference/destructuringInFunctionType.types b/tests/baselines/reference/destructuringInFunctionType.types index c6c0f439ac515..b5b0ff041c62b 100644 --- a/tests/baselines/reference/destructuringInFunctionType.types +++ b/tests/baselines/reference/destructuringInFunctionType.types @@ -9,7 +9,7 @@ interface c { c } >c : any type T1 = ([a, b, c]); ->T1 : [a, b, c] +>T1 : T1 type F1 = ([a, b, c]) => void; >F1 : F1 @@ -26,7 +26,7 @@ type F2 = ({ a }) => void; >a : any type T3 = ([{ a: b }, { b: a }]); ->T3 : [{ a: b; }, { b: a; }] +>T3 : T3 >a : b >b : a @@ -38,7 +38,7 @@ type F3 = ([{ a: b }, { b: a }]) => void; >a : any type T4 = ([{ a: [b, c] }]); ->T4 : [{ a: [b, c]; }] +>T4 : T4 >a : [b, c] type F4 = ([{ a: [b, c] }]) => void; diff --git a/tests/baselines/reference/destructuringParameterProperties1.types b/tests/baselines/reference/destructuringParameterProperties1.types index ff12edbac2e17..13bacf49b1330 100644 --- a/tests/baselines/reference/destructuringParameterProperties1.types +++ b/tests/baselines/reference/destructuringParameterProperties1.types @@ -10,7 +10,7 @@ class C1 { } type TupleType1 = [string, number, boolean]; ->TupleType1 : [string, number, boolean] +>TupleType1 : TupleType1 class C2 { >C2 : C2 diff --git a/tests/baselines/reference/destructuringParameterProperties5.types b/tests/baselines/reference/destructuringParameterProperties5.types index 60c3d074c6ef6..976b79e94957b 100644 --- a/tests/baselines/reference/destructuringParameterProperties5.types +++ b/tests/baselines/reference/destructuringParameterProperties5.types @@ -6,7 +6,7 @@ type ObjType1 = { x: number; y: string; z: boolean } >z : boolean type TupleType1 = [ObjType1, number, string] ->TupleType1 : [ObjType1, number, string] +>TupleType1 : TupleType1 class C1 { >C1 : C1 diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt index 68ea92f8fb559..d396026717744 100644 --- a/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt @@ -4,18 +4,9 @@ tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts( tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(7,6): error TS2456: Type alias 'T0_3' circularly references itself. tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(11,6): error TS2456: Type alias 'T1' circularly references itself. tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(14,6): error TS2456: Type alias 'T2' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(16,6): error TS2456: Type alias 'T2_1' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(19,6): error TS2456: Type alias 'T3' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(22,6): error TS2456: Type alias 'T4' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(25,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(26,6): error TS2456: Type alias 'T5' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(29,6): error TS2456: Type alias 'T6' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(30,6): error TS2456: Type alias 'T7' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(31,5): error TS2502: 'yy' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(32,6): error TS2456: Type alias 'T8' circularly references itself. -==== tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts (15 errors) ==== +==== tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts (6 errors) ==== // It is an error for the type specified in a type alias to depend on that type alias // A type alias directly depends on the type it aliases. @@ -44,40 +35,22 @@ tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts( !!! error TS2456: Type alias 'T2' circularly references itself. class C {} type T2_1 = T2_1[] | number - ~~~~ -!!! error TS2456: Type alias 'T2_1' circularly references itself. // An array type directly depends on its element type. type T3 = T3[] - ~~ -!!! error TS2456: Type alias 'T3' circularly references itself. // A tuple type directly depends on each of its element types. type T4 = [number, T4] - ~~ -!!! error TS2456: Type alias 'T4' circularly references itself. // A type query directly depends on the type of the referenced entity. var x: T5[] = [] - ~ -!!! error TS2502: 'x' is referenced directly or indirectly in its own type annotation. type T5 = typeof x - ~~ -!!! error TS2456: Type alias 'T5' circularly references itself. class C1 {} type T6 = T7 | number - ~~ -!!! error TS2456: Type alias 'T6' circularly references itself. type T7 = typeof yy - ~~ -!!! error TS2456: Type alias 'T7' circularly references itself. var yy: [string, T8[]]; - ~~ -!!! error TS2502: 'yy' is referenced directly or indirectly in its own type annotation. type T8 = C - ~~ -!!! error TS2456: Type alias 'T8' circularly references itself. // legal cases type T9 = () => T9 diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.types b/tests/baselines/reference/directDependenceBetweenTypeAliases.types index 3363b20b85199..431b65eea8ccf 100644 --- a/tests/baselines/reference/directDependenceBetweenTypeAliases.types +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.types @@ -27,40 +27,40 @@ class C {} >C : C type T2_1 = T2_1[] | number ->T2_1 : any +>T2_1 : T2_1 // An array type directly depends on its element type. type T3 = T3[] ->T3 : any +>T3 : T3 // A tuple type directly depends on each of its element types. type T4 = [number, T4] ->T4 : any +>T4 : T4 // A type query directly depends on the type of the referenced entity. var x: T5[] = [] ->x : any +>x : any[][][][][][][][][][][] >[] : undefined[] type T5 = typeof x ->T5 : any ->x : any +>T5 : any[][][][][][][][][][][] +>x : any[][][][][][][][][][][] class C1 {} >C1 : C1 type T6 = T7 | number ->T6 : any +>T6 : T6 type T7 = typeof yy ->T7 : any ->yy : any +>T7 : [string, C[]] +>yy : [string, C[]] var yy: [string, T8[]]; ->yy : any +>yy : [string, C[]] type T8 = C ->T8 : any +>T8 : C // legal cases type T9 = () => T9 @@ -72,17 +72,17 @@ type T10 = { x: T10 } | { new(v: T10): string } >v : T10 type T11 = T12[] ->T11 : [{ x: [any, string][]; }, string][] +>T11 : T11 type T12 = [T13, string] ->T12 : [{ x: [any, string][]; }, string] +>T12 : T12 type T13 = typeof zz ->T13 : { x: [any, string][]; } ->zz : { x: [any, string][]; } +>T13 : { x: T11; } +>zz : { x: T11; } var zz: { x: T11 } ->zz : { x: [any, string][]; } ->x : [{ x: [any, string][]; }, string][] +>zz : { x: T11; } +>x : T11 diff --git a/tests/baselines/reference/indexedAccessPrivateMemberOfGenericConstraint.types b/tests/baselines/reference/indexedAccessPrivateMemberOfGenericConstraint.types index abdbaa8486244..f3a96fba6a813 100644 --- a/tests/baselines/reference/indexedAccessPrivateMemberOfGenericConstraint.types +++ b/tests/baselines/reference/indexedAccessPrivateMemberOfGenericConstraint.types @@ -14,7 +14,7 @@ class B { } type X = [T["a"], (T | B)["a"]]; ->X : [T["a"], (B | T)["a"]] +>X : X type Y = T["a"]; >Y : T["a"] diff --git a/tests/baselines/reference/inferTypes1.types b/tests/baselines/reference/inferTypes1.types index 2696b520ae8a4..02fa41fe4c8bf 100644 --- a/tests/baselines/reference/inferTypes1.types +++ b/tests/baselines/reference/inferTypes1.types @@ -269,19 +269,19 @@ type T78 = T extends T76 ? T76 : never; >T78 : T78 type Foo = [T, U]; ->Foo : [T, U] +>Foo : Foo type Bar = T extends Foo ? Foo : never; >Bar : Bar type T90 = Bar<[string, string]>; // [string, string] ->T90 : [string, string] +>T90 : Foo type T91 = Bar<[string, "a"]>; // [string, "a"] ->T91 : [string, "a"] +>T91 : Foo type T92 = Bar<[string, "a"] & { x: string }>; // [string, "a"] ->T92 : [string, "a"] +>T92 : Foo >x : string type T93 = Bar<["a", string]>; // never @@ -371,13 +371,13 @@ const z2: string = ex.obj.nested.attr; // Repros from #21631 type A1> = [T, U]; ->A1 : [T, U] +>A1 : A1 type B1 = S extends A1 ? [T, U] : never; >B1 : B1 type A2 = [T, U]; ->A2 : [T, U] +>A2 : A2 type B2 = S extends A2 ? [T, U] : never; >B2 : B2 diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersection.types b/tests/baselines/reference/interfaceExtendsObjectIntersection.types index cc166a6e57c55..af63896907833 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersection.types +++ b/tests/baselines/reference/interfaceExtendsObjectIntersection.types @@ -15,10 +15,10 @@ type T4 = new () => { a: number }; >a : number type T5 = number[]; ->T5 : number[] +>T5 : T5 type T6 = [string, number]; ->T6 : [string, number] +>T6 : T6 type T7 = { [P in 'a' | 'b' | 'c']: string }; >T7 : T7 diff --git a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.types b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.types index 6b81e8d2f5413..2fc15b5399411 100644 --- a/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.types +++ b/tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.types @@ -8,10 +8,10 @@ type T2 = T1 & { b: number }; >b : number type T3 = number[]; ->T3 : number[] +>T3 : T3 type T4 = [string, number]; ->T4 : [string, number] +>T4 : T4 type T5 = { [P in 'a' | 'b' | 'c']: string }; >T5 : T5 diff --git a/tests/baselines/reference/intersectionTypeWithLeadingOperator.types b/tests/baselines/reference/intersectionTypeWithLeadingOperator.types index 9961f051f7f38..826da4d8c51de 100644 --- a/tests/baselines/reference/intersectionTypeWithLeadingOperator.types +++ b/tests/baselines/reference/intersectionTypeWithLeadingOperator.types @@ -12,7 +12,7 @@ type B = >bar : number type C = [& { foo: 1 } & { bar: 2 }, & { foo: 3 } & { bar: 4 }]; ->C : [{ foo: 1; } & { bar: 2; }, { foo: 3; } & { bar: 4; }] +>C : C >foo : 1 >bar : 2 >foo : 3 diff --git a/tests/baselines/reference/jsxChildrenSingleChildConfusableWithMultipleChildrenNoError.types b/tests/baselines/reference/jsxChildrenSingleChildConfusableWithMultipleChildrenNoError.types index dd302f4067963..59292bac60f0d 100644 --- a/tests/baselines/reference/jsxChildrenSingleChildConfusableWithMultipleChildrenNoError.types +++ b/tests/baselines/reference/jsxChildrenSingleChildConfusableWithMultipleChildrenNoError.types @@ -5,12 +5,12 @@ import * as React from 'react' >React : typeof React type Tab = [string, React.ReactNode] // [tabName, tabContent] ->Tab : [string, React.ReactNode] +>Tab : Tab >React : any interface Props { children: Tab[] ->children : [string, React.ReactNode][] +>children : Tab[] } function TabLayout(props: Props) { diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types index 2bb394ec12055..3f443a735cbe3 100644 --- a/tests/baselines/reference/mapOnTupleTypes02.types +++ b/tests/baselines/reference/mapOnTupleTypes02.types @@ -1,15 +1,15 @@ === tests/cases/compiler/mapOnTupleTypes02.ts === export type Point = [number, number]; ->Point : [number, number] +>Point : Point export function increment(point: Point) { ->increment : (point: [number, number]) => number[] ->point : [number, number] +>increment : (point: Point) => number[] +>point : Point return point.map(d => d + 1); >point.map(d => d + 1) : number[] >point.map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] ->point : [number, number] +>point : Point >map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] >d => d + 1 : (d: number) => number >d : number diff --git a/tests/baselines/reference/optionalTupleElements1.errors.txt b/tests/baselines/reference/optionalTupleElements1.errors.txt index ac9f5f244da2d..bb5fd2c01d8cb 100644 --- a/tests/baselines/reference/optionalTupleElements1.errors.txt +++ b/tests/baselines/reference/optionalTupleElements1.errors.txt @@ -1,25 +1,25 @@ tests/cases/conformance/types/tuple/optionalTupleElements1.ts(11,29): error TS1257: A required element cannot follow an optional element. -tests/cases/conformance/types/tuple/optionalTupleElements1.ts(15,5): error TS2322: Type '[number, string, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'. +tests/cases/conformance/types/tuple/optionalTupleElements1.ts(15,5): error TS2322: Type 'T2' is not assignable to type 'T1'. Types of property '2' are incompatible. Type 'boolean | undefined' is not assignable to type 'boolean'. Type 'undefined' is not assignable to type 'boolean'. -tests/cases/conformance/types/tuple/optionalTupleElements1.ts(16,5): error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'. +tests/cases/conformance/types/tuple/optionalTupleElements1.ts(16,5): error TS2322: Type 'T3' is not assignable to type 'T1'. Types of property '1' are incompatible. Type 'string | undefined' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -tests/cases/conformance/types/tuple/optionalTupleElements1.ts(17,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'. +tests/cases/conformance/types/tuple/optionalTupleElements1.ts(17,5): error TS2322: Type 'T4' is not assignable to type 'T1'. Types of property '0' are incompatible. Type 'number | undefined' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -tests/cases/conformance/types/tuple/optionalTupleElements1.ts(20,5): error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, (boolean | undefined)?]'. +tests/cases/conformance/types/tuple/optionalTupleElements1.ts(20,5): error TS2322: Type 'T3' is not assignable to type 'T2'. Types of property '1' are incompatible. Type 'string | undefined' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -tests/cases/conformance/types/tuple/optionalTupleElements1.ts(21,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, (boolean | undefined)?]'. +tests/cases/conformance/types/tuple/optionalTupleElements1.ts(21,5): error TS2322: Type 'T4' is not assignable to type 'T2'. Types of property '0' are incompatible. Type 'number | undefined' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -tests/cases/conformance/types/tuple/optionalTupleElements1.ts(25,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, (string | undefined)?, (boolean | undefined)?]'. +tests/cases/conformance/types/tuple/optionalTupleElements1.ts(25,5): error TS2322: Type 'T4' is not assignable to type 'T3'. Types of property '0' are incompatible. Type 'number | undefined' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. @@ -44,19 +44,19 @@ tests/cases/conformance/types/tuple/optionalTupleElements1.ts(25,5): error TS232 t1 = t1; t1 = t2; // Error ~~ -!!! error TS2322: Type '[number, string, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'. +!!! error TS2322: Type 'T2' is not assignable to type 'T1'. !!! error TS2322: Types of property '2' are incompatible. !!! error TS2322: Type 'boolean | undefined' is not assignable to type 'boolean'. !!! error TS2322: Type 'undefined' is not assignable to type 'boolean'. t1 = t3; // Error ~~ -!!! error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'. +!!! error TS2322: Type 'T3' is not assignable to type 'T1'. !!! error TS2322: Types of property '1' are incompatible. !!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. t1 = t4; // Error ~~ -!!! error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'. +!!! error TS2322: Type 'T4' is not assignable to type 'T1'. !!! error TS2322: Types of property '0' are incompatible. !!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. @@ -64,13 +64,13 @@ tests/cases/conformance/types/tuple/optionalTupleElements1.ts(25,5): error TS232 t2 = t2; t2 = t3; // Error ~~ -!!! error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, (boolean | undefined)?]'. +!!! error TS2322: Type 'T3' is not assignable to type 'T2'. !!! error TS2322: Types of property '1' are incompatible. !!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. t2 = t4; // Error ~~ -!!! error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, (boolean | undefined)?]'. +!!! error TS2322: Type 'T4' is not assignable to type 'T2'. !!! error TS2322: Types of property '0' are incompatible. !!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. @@ -79,7 +79,7 @@ tests/cases/conformance/types/tuple/optionalTupleElements1.ts(25,5): error TS232 t3 = t3; t3 = t4; // Error ~~ -!!! error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, (string | undefined)?, (boolean | undefined)?]'. +!!! error TS2322: Type 'T4' is not assignable to type 'T3'. !!! error TS2322: Types of property '0' are incompatible. !!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. diff --git a/tests/baselines/reference/optionalTupleElements1.types b/tests/baselines/reference/optionalTupleElements1.types index 630a54df5171d..b784bf72e5843 100644 --- a/tests/baselines/reference/optionalTupleElements1.types +++ b/tests/baselines/reference/optionalTupleElements1.types @@ -1,15 +1,15 @@ === tests/cases/conformance/types/tuple/optionalTupleElements1.ts === type T1 = [number, string, boolean]; ->T1 : [number, string, boolean] +>T1 : T1 type T2 = [number, string, boolean?]; ->T2 : [number, string, (boolean | undefined)?] +>T2 : T2 type T3 = [number, string?, boolean?]; ->T3 : [number, (string | undefined)?, (boolean | undefined)?] +>T3 : T3 type T4 = [number?, string?, boolean?]; ->T4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>T4 : T4 type L1 = T1["length"]; >L1 : 3 @@ -24,122 +24,122 @@ type L4 = T4["length"]; >L4 : 0 | 3 | 2 | 1 type T5 = [number, string?, boolean]; // Error ->T5 : [number, string | undefined, boolean] +>T5 : T5 function f1(t1: T1, t2: T2, t3: T3, t4: T4) { ->f1 : (t1: [number, string, boolean], t2: [number, string, (boolean | undefined)?], t3: [number, (string | undefined)?, (boolean | undefined)?], t4: [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]) => void ->t1 : [number, string, boolean] ->t2 : [number, string, (boolean | undefined)?] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>f1 : (t1: T1, t2: T2, t3: T3, t4: T4) => void +>t1 : T1 +>t2 : T2 +>t3 : T3 +>t4 : T4 t1 = t1; ->t1 = t1 : [number, string, boolean] ->t1 : [number, string, boolean] ->t1 : [number, string, boolean] +>t1 = t1 : T1 +>t1 : T1 +>t1 : T1 t1 = t2; // Error ->t1 = t2 : [number, string, (boolean | undefined)?] ->t1 : [number, string, boolean] ->t2 : [number, string, (boolean | undefined)?] +>t1 = t2 : T2 +>t1 : T1 +>t2 : T2 t1 = t3; // Error ->t1 = t3 : [number, (string | undefined)?, (boolean | undefined)?] ->t1 : [number, string, boolean] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] +>t1 = t3 : T3 +>t1 : T1 +>t3 : T3 t1 = t4; // Error ->t1 = t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] ->t1 : [number, string, boolean] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t1 = t4 : T4 +>t1 : T1 +>t4 : T4 t2 = t1; ->t2 = t1 : [number, string, boolean] ->t2 : [number, string, (boolean | undefined)?] ->t1 : [number, string, boolean] +>t2 = t1 : T1 +>t2 : T2 +>t1 : T1 t2 = t2; ->t2 = t2 : [number, string, (boolean | undefined)?] ->t2 : [number, string, (boolean | undefined)?] ->t2 : [number, string, (boolean | undefined)?] +>t2 = t2 : T2 +>t2 : T2 +>t2 : T2 t2 = t3; // Error ->t2 = t3 : [number, (string | undefined)?, (boolean | undefined)?] ->t2 : [number, string, (boolean | undefined)?] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] +>t2 = t3 : T3 +>t2 : T2 +>t3 : T3 t2 = t4; // Error ->t2 = t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] ->t2 : [number, string, (boolean | undefined)?] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t2 = t4 : T4 +>t2 : T2 +>t4 : T4 t3 = t1; ->t3 = t1 : [number, string, boolean] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] ->t1 : [number, string, boolean] +>t3 = t1 : T1 +>t3 : T3 +>t1 : T1 t3 = t2; ->t3 = t2 : [number, string, (boolean | undefined)?] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] ->t2 : [number, string, (boolean | undefined)?] +>t3 = t2 : T2 +>t3 : T3 +>t2 : T2 t3 = t3; ->t3 = t3 : [number, (string | undefined)?, (boolean | undefined)?] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] +>t3 = t3 : T3 +>t3 : T3 +>t3 : T3 t3 = t4; // Error ->t3 = t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t3 = t4 : T4 +>t3 : T3 +>t4 : T4 t4 = t1; ->t4 = t1 : [number, string, boolean] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] ->t1 : [number, string, boolean] +>t4 = t1 : T1 +>t4 : T4 +>t1 : T1 t4 = t2; ->t4 = t2 : [number, string, (boolean | undefined)?] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] ->t2 : [number, string, (boolean | undefined)?] +>t4 = t2 : T2 +>t4 : T4 +>t2 : T2 t4 = t3; ->t4 = t3 : [number, (string | undefined)?, (boolean | undefined)?] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] +>t4 = t3 : T3 +>t4 : T4 +>t3 : T3 t4 = t4; ->t4 = t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t4 = t4 : T4 +>t4 : T4 +>t4 : T4 } let t2: T2; ->t2 : [number, string, (boolean | undefined)?] +>t2 : T2 let t3: T3; ->t3 : [number, (string | undefined)?, (boolean | undefined)?] +>t3 : T3 let t4: T4; ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t4 : T4 t2 = [42, "hello"]; >t2 = [42, "hello"] : [number, string] ->t2 : [number, string, (boolean | undefined)?] +>t2 : T2 >[42, "hello"] : [number, string] >42 : 42 >"hello" : "hello" t3 = [42, "hello"]; >t3 = [42, "hello"] : [number, string] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] +>t3 : T3 >[42, "hello"] : [number, string] >42 : 42 >"hello" : "hello" t3 = [42,,true] >t3 = [42,,true] : [number, undefined, true] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] +>t3 : T3 >[42,,true] : [number, undefined, true] >42 : 42 > : undefined @@ -147,20 +147,20 @@ t3 = [42,,true] t3 = [42]; >t3 = [42] : [number] ->t3 : [number, (string | undefined)?, (boolean | undefined)?] +>t3 : T3 >[42] : [number] >42 : 42 t4 = [42, "hello"]; >t4 = [42, "hello"] : [number, string] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t4 : T4 >[42, "hello"] : [number, string] >42 : 42 >"hello" : "hello" t4 = [42,,true]; >t4 = [42,,true] : [number, undefined, true] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t4 : T4 >[42,,true] : [number, undefined, true] >42 : 42 > : undefined @@ -168,7 +168,7 @@ t4 = [42,,true]; t4 = [,"hello", true]; >t4 = [,"hello", true] : [undefined, string, true] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t4 : T4 >[,"hello", true] : [undefined, string, true] > : undefined >"hello" : "hello" @@ -176,7 +176,7 @@ t4 = [,"hello", true]; t4 = [,,true]; >t4 = [,,true] : [undefined, undefined, true] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t4 : T4 >[,,true] : [undefined, undefined, true] > : undefined > : undefined @@ -184,6 +184,6 @@ t4 = [,,true]; t4 = []; >t4 = [] : [] ->t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?] +>t4 : T4 >[] : [] diff --git a/tests/baselines/reference/readonlyArraysAndTuples.types b/tests/baselines/reference/readonlyArraysAndTuples.types index 5075319ef9550..2d4086a0193bd 100644 --- a/tests/baselines/reference/readonlyArraysAndTuples.types +++ b/tests/baselines/reference/readonlyArraysAndTuples.types @@ -1,6 +1,6 @@ === tests/cases/conformance/types/tuple/readonlyArraysAndTuples.ts === type T10 = string[]; ->T10 : string[] +>T10 : T10 type T11 = Array; >T11 : string[] @@ -12,7 +12,7 @@ type T13 = ReadonlyArray; >T13 : readonly string[] type T20 = [number, number]; ->T20 : [number, number] +>T20 : T20 type T21 = readonly [number, number]; >T21 : readonly [number, number] diff --git a/tests/baselines/reference/readonlyArraysAndTuples2.types b/tests/baselines/reference/readonlyArraysAndTuples2.types index 9e49820fdbea4..7b8c71248067b 100644 --- a/tests/baselines/reference/readonlyArraysAndTuples2.types +++ b/tests/baselines/reference/readonlyArraysAndTuples2.types @@ -1,6 +1,6 @@ === tests/cases/conformance/types/tuple/readonlyArraysAndTuples2.ts === type T10 = string[]; ->T10 : string[] +>T10 : T10 type T11 = Array; >T11 : string[] @@ -12,7 +12,7 @@ type T13 = ReadonlyArray; >T13 : readonly string[] type T20 = [number, number]; ->T20 : [number, number] +>T20 : T20 type T21 = readonly [number, number]; >T21 : readonly [number, number] diff --git a/tests/baselines/reference/recursiveMappedTypes.types b/tests/baselines/reference/recursiveMappedTypes.types index 34cfd2d610062..02a555cdcb138 100644 --- a/tests/baselines/reference/recursiveMappedTypes.types +++ b/tests/baselines/reference/recursiveMappedTypes.types @@ -25,10 +25,10 @@ export type Circular = {[P in keyof T]: Circular}; >Circular : Circular type tup = [number, number, number, number]; ->tup : [number, number, number, number] +>tup : tup function foo(arg: Circular): tup { ->foo : (arg: any) => [number, number, number, number] +>foo : (arg: any) => tup >arg : any return arg; @@ -44,10 +44,10 @@ type DeepMap = { }; type tpl = [string, [string, [string]]]; ->tpl : [string, [string, [string]]] +>tpl : tpl type arr = string[][]; ->arr : string[][] +>arr : arr type t1 = DeepMap; // [number, [number, [number]]] >t1 : [number, [number, [number]]] diff --git a/tests/baselines/reference/recursiveResolveTypeMembers.errors.txt b/tests/baselines/reference/recursiveResolveTypeMembers.errors.txt index ad5fe6dc1aedc..7bb5c5549841d 100644 --- a/tests/baselines/reference/recursiveResolveTypeMembers.errors.txt +++ b/tests/baselines/reference/recursiveResolveTypeMembers.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/recursiveResolveTypeMembers.ts(4,49): error TS2577: Return type annotation circularly references itself. +tests/cases/compiler/recursiveResolveTypeMembers.ts(4,49): error TS2589: Type instantiation is excessively deep and possibly infinite. tests/cases/compiler/recursiveResolveTypeMembers.ts(4,58): error TS2304: Cannot find name 'H'. tests/cases/compiler/recursiveResolveTypeMembers.ts(4,62): error TS2574: A rest element type must be an array type. tests/cases/compiler/recursiveResolveTypeMembers.ts(4,79): error TS2304: Cannot find name 'R'. @@ -10,7 +10,7 @@ tests/cases/compiler/recursiveResolveTypeMembers.ts(4,79): error TS2304: Cannot type PromisedTuple void> = U extends (h: infer H, ...args: infer R) => [Promise, ...PromisedTuple] ? [] : [] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2577: Return type annotation circularly references itself. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. ~ !!! error TS2304: Cannot find name 'H'. ~~~~~~~~~~~~~~~~~~~ diff --git a/tests/baselines/reference/recursiveTypesWithTypeof.errors.txt b/tests/baselines/reference/recursiveTypesWithTypeof.errors.txt index 0604e38bd94d9..2807613c3d985 100644 --- a/tests/baselines/reference/recursiveTypesWithTypeof.errors.txt +++ b/tests/baselines/reference/recursiveTypesWithTypeof.errors.txt @@ -3,7 +3,7 @@ tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithType tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(6,5): error TS2502: 'e' is referenced directly or indirectly in its own type annotation. tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(10,5): error TS2502: 'f' is referenced directly or indirectly in its own type annotation. tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(12,5): error TS2502: 'f2' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(14,5): error TS2502: 'f3' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(15,5): error TS2403: Subsequent variable declarations must have the same type. Variable 'f3' must be of type 'Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[]', but here has type 'any'. tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(51,5): error TS2502: 'hy3' is referenced directly or indirectly in its own type annotation. @@ -32,9 +32,10 @@ tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithType !!! error TS2502: 'f2' is referenced directly or indirectly in its own type annotation. var f2: any; var f3: Foo[]; - ~~ -!!! error TS2502: 'f3' is referenced directly or indirectly in its own type annotation. var f3: any; + ~~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'f3' must be of type 'Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[]', but here has type 'any'. +!!! related TS6203 tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts:14:5: 'f3' was also declared here. // None of these declarations should have any errors! // Truly recursive types diff --git a/tests/baselines/reference/recursiveTypesWithTypeof.types b/tests/baselines/reference/recursiveTypesWithTypeof.types index 5625e7919cd2a..1a527bfa470b1 100644 --- a/tests/baselines/reference/recursiveTypesWithTypeof.types +++ b/tests/baselines/reference/recursiveTypesWithTypeof.types @@ -37,11 +37,11 @@ var f2: any; >f2 : any var f3: Foo[]; ->f3 : any ->f3 : any +>f3 : Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[] +>f3 : Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[] var f3: any; ->f3 : any +>f3 : Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[] // None of these declarations should have any errors! // Truly recursive types diff --git a/tests/baselines/reference/restTupleElements1.types b/tests/baselines/reference/restTupleElements1.types index ffa20bf503ede..88c98395f21c3 100644 --- a/tests/baselines/reference/restTupleElements1.types +++ b/tests/baselines/reference/restTupleElements1.types @@ -1,42 +1,42 @@ === tests/cases/conformance/types/tuple/restTupleElements1.ts === type T00 = [string?]; ->T00 : [(string | undefined)?] +>T00 : T00 type T01 = [string, string?]; ->T01 : [string, (string | undefined)?] +>T01 : T01 type T02 = [string?, string]; // Error ->T02 : [string | undefined, string] +>T02 : T02 type T03 = [...string[]]; ->T03 : string[] +>T03 : T03 type T04 = [...[...string[]]]; ->T04 : string[] +>T04 : T04 type T05 = [...[...[...string[]]]]; ->T05 : string[] +>T05 : T05 type T06 = [string, ...string[]]; ->T06 : [string, ...string[]] +>T06 : T06 type T07 = [...string[], string]; // Error ->T07 : [string[], string] +>T07 : T07 type T08 = [...string]; // Error ->T08 : string[] +>T08 : T08 type T09 = [...string?]; // Error ->T09 : (string | null)[] +>T09 : T09 type T10 = [string, ...[...string[]]]; ->T10 : [string, ...string[]] +>T10 : T10 type T11 = [string, ...[...[...string[]]]]; ->T11 : [string, ...string[]] +>T11 : T11 type T15 = [boolean, number, ...string[]]; ->T15 : [boolean, number, ...string[]] +>T15 : T15 type L15 = T15["length"]; // number >L15 : number @@ -101,7 +101,7 @@ assign<[number, ...number[]], [number, number, number, string]>(); // Error >assign : () => void type T20 = [number, string, ...boolean[]]; ->T20 : [number, string, ...boolean[]] +>T20 : T20 type T21 = T20[0]; >T21 : number @@ -128,7 +128,7 @@ type T28 = T20[number]; >T28 : string | number | boolean declare const t: T20; ->t : [number, string, ...boolean[]] +>t : T20 declare const x: number; >x : number @@ -136,31 +136,31 @@ declare const x: number; let e0 = t[0]; // number >e0 : number >t[0] : number ->t : [number, string, ...boolean[]] +>t : T20 >0 : 0 let e1 = t[1]; // string >e1 : string >t[1] : string ->t : [number, string, ...boolean[]] +>t : T20 >1 : 1 let e2 = t[2]; // boolean >e2 : boolean >t[2] : boolean ->t : [number, string, ...boolean[]] +>t : T20 >2 : 2 let e3 = t[3]; // boolean >e3 : boolean >t[3] : boolean ->t : [number, string, ...boolean[]] +>t : T20 >3 : 3 let ex = t[x]; // number | string | boolean >ex : string | number | boolean >t[x] : string | number | boolean ->t : [number, string, ...boolean[]] +>t : T20 >x : number declare function f0(x: [T, ...U[]]): [T, U]; diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern.types b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern.types index 8ea11e087f861..eff8a93096310 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern.types @@ -7,27 +7,27 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, [string, string]]; ->MultiSkilledRobot : [string, [string, string]] +>MultiSkilledRobot : MultiSkilledRobot let robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" function getRobot() { ->getRobot : () => [number, string, string] +>getRobot : () => Robot return robotA; ->robotA : [number, string, string] +>robotA : Robot } let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, [string, string]] >"mower" : "mower" >["mowing", ""] : [string, string] @@ -35,7 +35,7 @@ let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -43,16 +43,16 @@ let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" function getMultiRobot() { ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot : () => MultiSkilledRobot return multiRobotA; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot } for (let [, nameA] = robotA, i = 0; i < 1; i++) { > : undefined >nameA : string ->robotA : [number, string, string] +>robotA : Robot >i : number >0 : 0 >i < 1 : boolean @@ -71,8 +71,8 @@ for (let [, nameA] = robotA, i = 0; i < 1; i++) { for (let [, nameA] = getRobot(), i = 0; i < 1; i++) { > : undefined >nameA : string ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i : number >0 : 0 >i < 1 : boolean @@ -114,7 +114,7 @@ for (let [, [primarySkillA, secondarySkillA]] = multiRobotA, i = 0; i < 1; i++) > : undefined >primarySkillA : string >secondarySkillA : string ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -134,8 +134,8 @@ for (let [, [primarySkillA, secondarySkillA]] = getMultiRobot(), i = 0; i < 1; i > : undefined >primarySkillA : string >secondarySkillA : string ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -178,7 +178,7 @@ for (let [, [primarySkillA, secondarySkillA]] = ["trimmer", ["trimming", "edging for (let [numberB] = robotA, i = 0; i < 1; i++) { >numberB : number ->robotA : [number, string, string] +>robotA : Robot >i : number >0 : 0 >i < 1 : boolean @@ -196,8 +196,8 @@ for (let [numberB] = robotA, i = 0; i < 1; i++) { } for (let [numberB] = getRobot(), i = 0; i < 1; i++) { >numberB : number ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i : number >0 : 0 >i < 1 : boolean @@ -236,7 +236,7 @@ for (let [numberB] = [2, "trimmer", "trimming"], i = 0; i < 1; i++) { } for (let [nameB] = multiRobotA, i = 0; i < 1; i++) { >nameB : string ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -254,8 +254,8 @@ for (let [nameB] = multiRobotA, i = 0; i < 1; i++) { } for (let [nameB] = getMultiRobot(), i = 0; i < 1; i++) { >nameB : string ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -298,7 +298,7 @@ for (let [numberA2, nameA2, skillA2] = robotA, i = 0; i < 1; i++) { >numberA2 : number >nameA2 : string >skillA2 : string ->robotA : [number, string, string] +>robotA : Robot >i : number >0 : 0 >i < 1 : boolean @@ -318,8 +318,8 @@ for (let [numberA2, nameA2, skillA2] = getRobot(), i = 0; i < 1; i++) { >numberA2 : number >nameA2 : string >skillA2 : string ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i : number >0 : 0 >i < 1 : boolean @@ -362,7 +362,7 @@ for (let [nameMA, [primarySkillA, secondarySkillA]] = multiRobotA, i = 0; i < 1; >nameMA : string >primarySkillA : string >secondarySkillA : string ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -382,8 +382,8 @@ for (let [nameMA, [primarySkillA, secondarySkillA]] = getMultiRobot(), i = 0; i >nameMA : string >primarySkillA : string >secondarySkillA : string ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -427,7 +427,7 @@ for (let [nameMA, [primarySkillA, secondarySkillA]] = ["trimmer", ["trimming", " for (let [numberA3, ...robotAInfo] = robotA, i = 0; i < 1; i++) { >numberA3 : number >robotAInfo : [string, string] ->robotA : [number, string, string] +>robotA : Robot >i : number >0 : 0 >i < 1 : boolean @@ -446,8 +446,8 @@ for (let [numberA3, ...robotAInfo] = robotA, i = 0; i < 1; i++) { for (let [numberA3, ...robotAInfo] = getRobot(), i = 0; i < 1; i++) { >numberA3 : number >robotAInfo : [string, string] ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i : number >0 : 0 >i < 1 : boolean @@ -487,7 +487,7 @@ for (let [numberA3, ...robotAInfo] = [2, "trimmer", "trimming"], i = 0; i < 1; i } for (let [...multiRobotAInfo] = multiRobotA, i = 0; i < 1; i++) { >multiRobotAInfo : [string, [string, string]] ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -505,8 +505,8 @@ for (let [...multiRobotAInfo] = multiRobotA, i = 0; i < 1; i++) { } for (let [...multiRobotAInfo] = getMultiRobot(), i = 0; i < 1; i++) { >multiRobotAInfo : [string, [string, string]] ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern2.types index 3f198ebc80f15..bfa1757d616ba 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPattern2.types @@ -7,27 +7,27 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, [string, string]]; ->MultiSkilledRobot : [string, [string, string]] +>MultiSkilledRobot : MultiSkilledRobot let robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" function getRobot() { ->getRobot : () => [number, string, string] +>getRobot : () => Robot return robotA; ->robotA : [number, string, string] +>robotA : Robot } let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, [string, string]] >"mower" : "mower" >["mowing", ""] : [string, string] @@ -35,7 +35,7 @@ let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -43,10 +43,10 @@ let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" function getMultiRobot() { ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot : () => MultiSkilledRobot return multiRobotA; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot } let nameA: string, primarySkillA: string, secondarySkillA: string; @@ -74,11 +74,11 @@ let i: number; for ([, nameA] = robotA, i = 0; i < 1; i++) { >[, nameA] = robotA, i = 0 : 0 ->[, nameA] = robotA : [number, string, string] +>[, nameA] = robotA : Robot >[, nameA] : [undefined, string] > : undefined >nameA : string ->robotA : [number, string, string] +>robotA : Robot >i = 0 : 0 >i : number >0 : 0 @@ -97,12 +97,12 @@ for ([, nameA] = robotA, i = 0; i < 1; i++) { } for ([, nameA] = getRobot(), i = 0; i < 1; i++) { >[, nameA] = getRobot(), i = 0 : 0 ->[, nameA] = getRobot() : [number, string, string] +>[, nameA] = getRobot() : Robot >[, nameA] : [undefined, string] > : undefined >nameA : string ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i = 0 : 0 >i : number >0 : 0 @@ -147,13 +147,13 @@ for ([, nameA] = [2, "trimmer", "trimming"], i = 0; i < 1; i++) { } for ([, [primarySkillA, secondarySkillA]] = multiRobotA, i = 0; i < 1; i++) { >[, [primarySkillA, secondarySkillA]] = multiRobotA, i = 0 : 0 ->[, [primarySkillA, secondarySkillA]] = multiRobotA : [string, [string, string]] +>[, [primarySkillA, secondarySkillA]] = multiRobotA : MultiSkilledRobot >[, [primarySkillA, secondarySkillA]] : [undefined, [string, string]] > : undefined >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -172,14 +172,14 @@ for ([, [primarySkillA, secondarySkillA]] = multiRobotA, i = 0; i < 1; i++) { } for ([, [primarySkillA, secondarySkillA]] = getMultiRobot(), i = 0; i < 1; i++) { >[, [primarySkillA, secondarySkillA]] = getMultiRobot(), i = 0 : 0 ->[, [primarySkillA, secondarySkillA]] = getMultiRobot() : [string, [string, string]] +>[, [primarySkillA, secondarySkillA]] = getMultiRobot() : MultiSkilledRobot >[, [primarySkillA, secondarySkillA]] : [undefined, [string, string]] > : undefined >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -228,10 +228,10 @@ for ([, [primarySkillA, secondarySkillA]] = ["trimmer", ["trimming", "edging"]], for ([numberB] = robotA, i = 0; i < 1; i++) { >[numberB] = robotA, i = 0 : 0 ->[numberB] = robotA : [number, string, string] +>[numberB] = robotA : Robot >[numberB] : [number] >numberB : number ->robotA : [number, string, string] +>robotA : Robot >i = 0 : 0 >i : number >0 : 0 @@ -250,11 +250,11 @@ for ([numberB] = robotA, i = 0; i < 1; i++) { } for ([numberB] = getRobot(), i = 0; i < 1; i++) { >[numberB] = getRobot(), i = 0 : 0 ->[numberB] = getRobot() : [number, string, string] +>[numberB] = getRobot() : Robot >[numberB] : [number] >numberB : number ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i = 0 : 0 >i : number >0 : 0 @@ -298,10 +298,10 @@ for ([numberB] = [2, "trimmer", "trimming"], i = 0; i < 1; i++) { } for ([nameB] = multiRobotA, i = 0; i < 1; i++) { >[nameB] = multiRobotA, i = 0 : 0 ->[nameB] = multiRobotA : [string, [string, string]] +>[nameB] = multiRobotA : MultiSkilledRobot >[nameB] : [string] >nameB : string ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -320,11 +320,11 @@ for ([nameB] = multiRobotA, i = 0; i < 1; i++) { } for ([nameB] = getMultiRobot(), i = 0; i < 1; i++) { >[nameB] = getMultiRobot(), i = 0 : 0 ->[nameB] = getMultiRobot() : [string, [string, string]] +>[nameB] = getMultiRobot() : MultiSkilledRobot >[nameB] : [string] >nameB : string ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -370,12 +370,12 @@ for ([nameB] = ["trimmer", ["trimming", "edging"]], i = 0; i < 1; i++) { for ([numberA2, nameA2, skillA2] = robotA, i = 0; i < 1; i++) { >[numberA2, nameA2, skillA2] = robotA, i = 0 : 0 ->[numberA2, nameA2, skillA2] = robotA : [number, string, string] +>[numberA2, nameA2, skillA2] = robotA : Robot >[numberA2, nameA2, skillA2] : [number, string, string] >numberA2 : number >nameA2 : string >skillA2 : string ->robotA : [number, string, string] +>robotA : Robot >i = 0 : 0 >i : number >0 : 0 @@ -394,13 +394,13 @@ for ([numberA2, nameA2, skillA2] = robotA, i = 0; i < 1; i++) { } for ([numberA2, nameA2, skillA2] = getRobot(), i = 0; i < 1; i++) { >[numberA2, nameA2, skillA2] = getRobot(), i = 0 : 0 ->[numberA2, nameA2, skillA2] = getRobot() : [number, string, string] +>[numberA2, nameA2, skillA2] = getRobot() : Robot >[numberA2, nameA2, skillA2] : [number, string, string] >numberA2 : number >nameA2 : string >skillA2 : string ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i = 0 : 0 >i : number >0 : 0 @@ -446,13 +446,13 @@ for ([numberA2, nameA2, skillA2] = [2, "trimmer", "trimming"], i = 0; i < 1; i++ } for ([nameMA, [primarySkillA, secondarySkillA]] = multiRobotA, i = 0; i < 1; i++) { >[nameMA, [primarySkillA, secondarySkillA]] = multiRobotA, i = 0 : 0 ->[nameMA, [primarySkillA, secondarySkillA]] = multiRobotA : [string, [string, string]] +>[nameMA, [primarySkillA, secondarySkillA]] = multiRobotA : MultiSkilledRobot >[nameMA, [primarySkillA, secondarySkillA]] : [string, [string, string]] >nameMA : string >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -471,14 +471,14 @@ for ([nameMA, [primarySkillA, secondarySkillA]] = multiRobotA, i = 0; i < 1; i++ } for ([nameMA, [primarySkillA, secondarySkillA]] = getMultiRobot(), i = 0; i < 1; i++) { >[nameMA, [primarySkillA, secondarySkillA]] = getMultiRobot(), i = 0 : 0 ->[nameMA, [primarySkillA, secondarySkillA]] = getMultiRobot() : [string, [string, string]] +>[nameMA, [primarySkillA, secondarySkillA]] = getMultiRobot() : MultiSkilledRobot >[nameMA, [primarySkillA, secondarySkillA]] : [string, [string, string]] >nameMA : string >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -527,12 +527,12 @@ for ([nameMA, [primarySkillA, secondarySkillA]] = ["trimmer", ["trimming", "edgi for ([numberA3, ...robotAInfo] = robotA, i = 0; i < 1; i++) { >[numberA3, ...robotAInfo] = robotA, i = 0 : 0 ->[numberA3, ...robotAInfo] = robotA : [number, string, string] +>[numberA3, ...robotAInfo] = robotA : Robot >[numberA3, ...robotAInfo] : [number, ...(string | number)[]] >numberA3 : number >...robotAInfo : string | number >robotAInfo : (string | number)[] ->robotA : [number, string, string] +>robotA : Robot >i = 0 : 0 >i : number >0 : 0 @@ -551,13 +551,13 @@ for ([numberA3, ...robotAInfo] = robotA, i = 0; i < 1; i++) { } for ([numberA3, ...robotAInfo] = getRobot(), i = 0; i < 1; i++) { >[numberA3, ...robotAInfo] = getRobot(), i = 0 : 0 ->[numberA3, ...robotAInfo] = getRobot() : [number, string, string] +>[numberA3, ...robotAInfo] = getRobot() : Robot >[numberA3, ...robotAInfo] : [number, ...(string | number)[]] >numberA3 : number >...robotAInfo : string | number >robotAInfo : (string | number)[] ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i = 0 : 0 >i : number >0 : 0 @@ -576,12 +576,12 @@ for ([numberA3, ...robotAInfo] = getRobot(), i = 0; i < 1; i++) { } for ([numberA3, ...robotAInfo] = [2, "trimmer", "trimming"], i = 0; i < 1; i++) { >[numberA3, ...robotAInfo] = [2, "trimmer", "trimming"], i = 0 : 0 ->[numberA3, ...robotAInfo] = [2, "trimmer", "trimming"] : [number, string, string] +>[numberA3, ...robotAInfo] = [2, "trimmer", "trimming"] : Robot >[numberA3, ...robotAInfo] : [number, ...(string | number)[]] >numberA3 : number >...robotAInfo : string | number >robotAInfo : (string | number)[] ->[2, "trimmer", "trimming"] : [number, string, string] +>[2, "trimmer", "trimming"] : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -604,11 +604,11 @@ for ([numberA3, ...robotAInfo] = [2, "trimmer", "trimming"], i = 0; i < 1 } for ([...multiRobotAInfo] = multiRobotA, i = 0; i < 1; i++) { >[...multiRobotAInfo] = multiRobotA, i = 0 : 0 ->[...multiRobotAInfo] = multiRobotA : [string, [string, string]] +>[...multiRobotAInfo] = multiRobotA : MultiSkilledRobot >[...multiRobotAInfo] : (string | [string, string])[] >...multiRobotAInfo : string | [string, string] >multiRobotAInfo : (string | [string, string])[] ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -627,12 +627,12 @@ for ([...multiRobotAInfo] = multiRobotA, i = 0; i < 1; i++) { } for ([...multiRobotAInfo] = getMultiRobot(), i = 0; i < 1; i++) { >[...multiRobotAInfo] = getMultiRobot(), i = 0 : 0 ->[...multiRobotAInfo] = getMultiRobot() : [string, [string, string]] +>[...multiRobotAInfo] = getMultiRobot() : MultiSkilledRobot >[...multiRobotAInfo] : (string | [string, string])[] >...multiRobotAInfo : string | [string, string] >multiRobotAInfo : (string | [string, string])[] ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -651,11 +651,11 @@ for ([...multiRobotAInfo] = getMultiRobot(), i = 0; i < 1; i++) { } for ([...multiRobotAInfo] = ["trimmer", ["trimming", "edging"]], i = 0; i < 1; i++) { >[...multiRobotAInfo] = ["trimmer", ["trimming", "edging"]], i = 0 : 0 ->[...multiRobotAInfo] = ["trimmer", ["trimming", "edging"]] : [string, [string, string]] +>[...multiRobotAInfo] = ["trimmer", ["trimming", "edging"]] : MultiSkilledRobot >[...multiRobotAInfo] : (string | [string, string])[] >...multiRobotAInfo : string | [string, string] >multiRobotAInfo : (string | [string, string])[] ->["trimmer", ["trimming", "edging"]] : [string, [string, string]] +>["trimmer", ["trimming", "edging"]] : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.types b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.types index ee16f28a9d589..2dab0c1cd6b83 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues.types @@ -7,27 +7,27 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, string[]]; ->MultiSkilledRobot : [string, string[]] +>MultiSkilledRobot : MultiSkilledRobot let robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" function getRobot() { ->getRobot : () => [number, string, string] +>getRobot : () => Robot return robotA; ->robotA : [number, string, string] +>robotA : Robot } let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, string[]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, string[]] >"mower" : "mower" >["mowing", ""] : string[] @@ -35,7 +35,7 @@ let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, string[]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, string[]] >"trimmer" : "trimmer" >["trimming", "edging"] : string[] @@ -43,17 +43,17 @@ let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" function getMultiRobot() { ->getMultiRobot : () => [string, string[]] +>getMultiRobot : () => MultiSkilledRobot return multiRobotA; ->multiRobotA : [string, string[]] +>multiRobotA : MultiSkilledRobot } for (let [, nameA ="name"] = robotA, i = 0; i < 1; i++) { > : undefined >nameA : string >"name" : "name" ->robotA : [number, string, string] +>robotA : Robot >i : number >0 : 0 >i < 1 : boolean @@ -73,8 +73,8 @@ for (let [, nameA = "name"] = getRobot(), i = 0; i < 1; i++) { > : undefined >nameA : string >"name" : "name" ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i : number >0 : 0 >i < 1 : boolean @@ -128,7 +128,7 @@ for (let [, [ >["none", "none"] : [string, string] >"none" : "none" >"none" : "none" ->multiRobotA : [string, string[]] +>multiRobotA : MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -159,8 +159,8 @@ for (let [, [ >["none", "none"] : [string, string] >"none" : "none" >"none" : "none" ->getMultiRobot() : [string, string[]] ->getMultiRobot : () => [string, string[]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -216,7 +216,7 @@ for (let [numberB = -1] = robotA, i = 0; i < 1; i++) { >numberB : number >-1 : -1 >1 : 1 ->robotA : [number, string, string] +>robotA : Robot >i : number >0 : 0 >i < 1 : boolean @@ -236,8 +236,8 @@ for (let [numberB = -1] = getRobot(), i = 0; i < 1; i++) { >numberB : number >-1 : -1 >1 : 1 ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i : number >0 : 0 >i < 1 : boolean @@ -279,7 +279,7 @@ for (let [numberB = -1] = [2, "trimmer", "trimming"], i = 0; i < 1; i++) { for (let [nameB = "name"] = multiRobotA, i = 0; i < 1; i++) { >nameB : string >"name" : "name" ->multiRobotA : [string, string[]] +>multiRobotA : MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -298,8 +298,8 @@ for (let [nameB = "name"] = multiRobotA, i = 0; i < 1; i++) { for (let [nameB = "name"] = getMultiRobot(), i = 0; i < 1; i++) { >nameB : string >"name" : "name" ->getMultiRobot() : [string, string[]] ->getMultiRobot : () => [string, string[]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -347,7 +347,7 @@ for (let [numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = robotA, i = 0; i >"name" : "name" >skillA2 : string >"skill" : "skill" ->robotA : [number, string, string] +>robotA : Robot >i : number >0 : 0 >i < 1 : boolean @@ -371,8 +371,8 @@ for (let [numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = getRobot(), i = 0 >"name" : "name" >skillA2 : string >"skill" : "skill" ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i : number >0 : 0 >i < 1 : boolean @@ -435,7 +435,7 @@ for (let >"none" : "none" ] = multiRobotA, i = 0; i < 1; i++) { ->multiRobotA : [string, string[]] +>multiRobotA : MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -470,8 +470,8 @@ for (let [nameMA = "noName", >"none" : "none" ] = getMultiRobot(), i = 0; i < 1; i++) { ->getMultiRobot() : [string, string[]] ->getMultiRobot : () => [string, string[]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -532,7 +532,7 @@ for (let [numberA3 = -1, ...robotAInfo] = robotA, i = 0; i < 1; i++) { >-1 : -1 >1 : 1 >robotAInfo : [string, string] ->robotA : [number, string, string] +>robotA : Robot >i : number >0 : 0 >i < 1 : boolean @@ -553,8 +553,8 @@ for (let [numberA3 = -1, ...robotAInfo] = getRobot(), i = 0; i < 1; i++) { >-1 : -1 >1 : 1 >robotAInfo : [string, string] ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i : number >0 : 0 >i < 1 : boolean diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.types b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.types index 9175ee68dcaf8..aa06efe39657d 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringForArrayBindingPatternDefaultValues2.types @@ -7,27 +7,27 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, [string, string]]; ->MultiSkilledRobot : [string, [string, string]] +>MultiSkilledRobot : MultiSkilledRobot let robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" function getRobot() { ->getRobot : () => [number, string, string] +>getRobot : () => Robot return robotA; ->robotA : [number, string, string] +>robotA : Robot } let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, [string, string]] >"mower" : "mower" >["mowing", ""] : [string, string] @@ -35,7 +35,7 @@ let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -43,10 +43,10 @@ let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" function getMultiRobot() { ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot : () => MultiSkilledRobot return multiRobotA; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot } let nameA: string, primarySkillA: string, secondarySkillA: string; @@ -74,13 +74,13 @@ let i: number; for ([, nameA = "name"] = robotA, i = 0; i < 1; i++) { >[, nameA = "name"] = robotA, i = 0 : 0 ->[, nameA = "name"] = robotA : [number, string, string] +>[, nameA = "name"] = robotA : Robot >[, nameA = "name"] : [undefined, string] > : undefined >nameA = "name" : "name" >nameA : string >"name" : "name" ->robotA : [number, string, string] +>robotA : Robot >i = 0 : 0 >i : number >0 : 0 @@ -99,14 +99,14 @@ for ([, nameA = "name"] = robotA, i = 0; i < 1; i++) { } for ([, nameA = "name"] = getRobot(), i = 0; i < 1; i++) { >[, nameA = "name"] = getRobot(), i = 0 : 0 ->[, nameA = "name"] = getRobot() : [number, string, string] +>[, nameA = "name"] = getRobot() : Robot >[, nameA = "name"] : [undefined, string] > : undefined >nameA = "name" : "name" >nameA : string >"name" : "name" ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i = 0 : 0 >i : number >0 : 0 @@ -153,7 +153,7 @@ for ([, nameA = "name"] = [2, "trimmer", "trimming"], i = 0; i < 1; i++) { } for ([, [ >[, [ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"]] = multiRobotA, i = 0 : 0 ->[, [ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"]] = multiRobotA : [string, [string, string]] +>[, [ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"]] = multiRobotA : MultiSkilledRobot >[, [ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"]] : [undefined, [string, string]] > : undefined >[ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"] : [string, string] @@ -173,7 +173,7 @@ for ([, [ >["none", "none"] : [string, string] >"none" : "none" >"none" : "none" ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -192,7 +192,7 @@ for ([, [ } for ([, [ >[, [ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"]] = getMultiRobot(), i = 0 : 0 ->[, [ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"]] = getMultiRobot() : [string, [string, string]] +>[, [ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"]] = getMultiRobot() : MultiSkilledRobot >[, [ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"]] : [undefined, [string, string]] > : undefined >[ primarySkillA = "primary", secondarySkillA = "secondary"] = ["none", "none"] : [string, string] @@ -212,8 +212,8 @@ for ([, [ >["none", "none"] : [string, string] >"none" : "none" >"none" : "none" ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -276,13 +276,13 @@ for ([, [ for ([numberB = -1] = robotA, i = 0; i < 1; i++) { >[numberB = -1] = robotA, i = 0 : 0 ->[numberB = -1] = robotA : [number, string, string] +>[numberB = -1] = robotA : Robot >[numberB = -1] : [number] >numberB = -1 : -1 >numberB : number >-1 : -1 >1 : 1 ->robotA : [number, string, string] +>robotA : Robot >i = 0 : 0 >i : number >0 : 0 @@ -301,14 +301,14 @@ for ([numberB = -1] = robotA, i = 0; i < 1; i++) { } for ([numberB = -1] = getRobot(), i = 0; i < 1; i++) { >[numberB = -1] = getRobot(), i = 0 : 0 ->[numberB = -1] = getRobot() : [number, string, string] +>[numberB = -1] = getRobot() : Robot >[numberB = -1] : [number] >numberB = -1 : -1 >numberB : number >-1 : -1 >1 : 1 ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i = 0 : 0 >i : number >0 : 0 @@ -355,12 +355,12 @@ for ([numberB = -1] = [2, "trimmer", "trimming"], i = 0; i < 1; i++) { } for ([nameB = "name"] = multiRobotA, i = 0; i < 1; i++) { >[nameB = "name"] = multiRobotA, i = 0 : 0 ->[nameB = "name"] = multiRobotA : [string, [string, string]] +>[nameB = "name"] = multiRobotA : MultiSkilledRobot >[nameB = "name"] : [string] >nameB = "name" : "name" >nameB : string >"name" : "name" ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -379,13 +379,13 @@ for ([nameB = "name"] = multiRobotA, i = 0; i < 1; i++) { } for ([nameB = "name"] = getMultiRobot(), i = 0; i < 1; i++) { >[nameB = "name"] = getMultiRobot(), i = 0 : 0 ->[nameB = "name"] = getMultiRobot() : [string, [string, string]] +>[nameB = "name"] = getMultiRobot() : MultiSkilledRobot >[nameB = "name"] : [string] >nameB = "name" : "name" >nameB : string >"name" : "name" ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -433,7 +433,7 @@ for ([nameB = "name"] = ["trimmer", ["trimming", "edging"]], i = 0; i < 1; i++) for ([numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = robotA, i = 0; i < 1; i++) { >[numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = robotA, i = 0 : 0 ->[numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = robotA : [number, string, string] +>[numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = robotA : Robot >[numberA2 = -1, nameA2 = "name", skillA2 = "skill"] : [number, string, string] >numberA2 = -1 : -1 >numberA2 : number @@ -445,7 +445,7 @@ for ([numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = robotA, i = 0; i < 1; >skillA2 = "skill" : "skill" >skillA2 : string >"skill" : "skill" ->robotA : [number, string, string] +>robotA : Robot >i = 0 : 0 >i : number >0 : 0 @@ -464,7 +464,7 @@ for ([numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = robotA, i = 0; i < 1; } for ([numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = getRobot(), i = 0; i < 1; i++) { >[numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = getRobot(), i = 0 : 0 ->[numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = getRobot() : [number, string, string] +>[numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = getRobot() : Robot >[numberA2 = -1, nameA2 = "name", skillA2 = "skill"] : [number, string, string] >numberA2 = -1 : -1 >numberA2 : number @@ -476,8 +476,8 @@ for ([numberA2 = -1, nameA2 = "name", skillA2 = "skill"] = getRobot(), i = 0; i >skillA2 = "skill" : "skill" >skillA2 : string >"skill" : "skill" ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i = 0 : 0 >i : number >0 : 0 @@ -548,7 +548,7 @@ for (let >"none" : "none" ] = multiRobotA, i = 0; i < 1; i++) { ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >i : number >0 : 0 >i < 1 : boolean @@ -566,7 +566,7 @@ for (let } for ([nameMA = "noName", >[nameMA = "noName", [ primarySkillA = "primary", secondarySkillA = "secondary" ] = ["none", "none"]] = getMultiRobot(), i = 0 : 0 ->[nameMA = "noName", [ primarySkillA = "primary", secondarySkillA = "secondary" ] = ["none", "none"]] = getMultiRobot() : [string, [string, string]] +>[nameMA = "noName", [ primarySkillA = "primary", secondarySkillA = "secondary" ] = ["none", "none"]] = getMultiRobot() : MultiSkilledRobot >[nameMA = "noName", [ primarySkillA = "primary", secondarySkillA = "secondary" ] = ["none", "none"]] : [string, [string, string]] >nameMA = "noName" : "noName" >nameMA : string @@ -592,8 +592,8 @@ for ([nameMA = "noName", >"none" : "none" ] = getMultiRobot(), i = 0; i < 1; i++) { ->getMultiRobot() : [string, [string, string]] ->getMultiRobot : () => [string, [string, string]] +>getMultiRobot() : MultiSkilledRobot +>getMultiRobot : () => MultiSkilledRobot >i = 0 : 0 >i : number >0 : 0 @@ -662,7 +662,7 @@ for ([nameMA = "noName", for ([numberA3 = -1, ...robotAInfo] = robotA, i = 0; i < 1; i++) { >[numberA3 = -1, ...robotAInfo] = robotA, i = 0 : 0 ->[numberA3 = -1, ...robotAInfo] = robotA : [number, string, string] +>[numberA3 = -1, ...robotAInfo] = robotA : Robot >[numberA3 = -1, ...robotAInfo] : [number, ...(string | number)[]] >numberA3 = -1 : -1 >numberA3 : number @@ -670,7 +670,7 @@ for ([numberA3 = -1, ...robotAInfo] = robotA, i = 0; i < 1; i++) { >1 : 1 >...robotAInfo : string | number >robotAInfo : (string | number)[] ->robotA : [number, string, string] +>robotA : Robot >i = 0 : 0 >i : number >0 : 0 @@ -689,7 +689,7 @@ for ([numberA3 = -1, ...robotAInfo] = robotA, i = 0; i < 1; i++) { } for ([numberA3 = -1, ...robotAInfo] = getRobot(), i = 0; i < 1; i++) { >[numberA3 = -1, ...robotAInfo] = getRobot(), i = 0 : 0 ->[numberA3 = -1, ...robotAInfo] = getRobot() : [number, string, string] +>[numberA3 = -1, ...robotAInfo] = getRobot() : Robot >[numberA3 = -1, ...robotAInfo] : [number, ...(string | number)[]] >numberA3 = -1 : -1 >numberA3 : number @@ -697,8 +697,8 @@ for ([numberA3 = -1, ...robotAInfo] = getRobot(), i = 0; i < 1; i++) { >1 : 1 >...robotAInfo : string | number >robotAInfo : (string | number)[] ->getRobot() : [number, string, string] ->getRobot : () => [number, string, string] +>getRobot() : Robot +>getRobot : () => Robot >i = 0 : 0 >i : number >0 : 0 @@ -717,7 +717,7 @@ for ([numberA3 = -1, ...robotAInfo] = getRobot(), i = 0; i < 1; i++) { } for ([numberA3 = -1, ...robotAInfo] = [2, "trimmer", "trimming"], i = 0; i < 1; i++) { >[numberA3 = -1, ...robotAInfo] = [2, "trimmer", "trimming"], i = 0 : 0 ->[numberA3 = -1, ...robotAInfo] = [2, "trimmer", "trimming"] : [number, string, string] +>[numberA3 = -1, ...robotAInfo] = [2, "trimmer", "trimming"] : Robot >[numberA3 = -1, ...robotAInfo] : [number, ...(string | number)[]] >numberA3 = -1 : -1 >numberA3 : number @@ -725,7 +725,7 @@ for ([numberA3 = -1, ...robotAInfo] = [2, "trimmer", "trimming"], i = 0; >1 : 1 >...robotAInfo : string | number >robotAInfo : (string | number)[] ->[2, "trimmer", "trimming"] : [number, string, string] +>[2, "trimmer", "trimming"] : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern.types b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern.types index 57fa951a2c797..f38bc8330ef75 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern.types @@ -7,40 +7,40 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, [string, string]]; ->MultiSkilledRobot : [string, [string, string]] +>MultiSkilledRobot : MultiSkilledRobot let robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" let robotB: Robot = [2, "trimmer", "trimming"]; ->robotB : [number, string, string] +>robotB : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" >"trimming" : "trimming" let robots = [robotA, robotB]; ->robots : [number, string, string][] ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>robots : Robot[] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot function getRobots() { ->getRobots : () => [number, string, string][] +>getRobots : () => Robot[] return robots; ->robots : [number, string, string][] +>robots : Robot[] } let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, [string, string]] >"mower" : "mower" >["mowing", ""] : [string, string] @@ -48,7 +48,7 @@ let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -56,22 +56,22 @@ let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" let multiRobots = [multiRobotA, multiRobotB]; ->multiRobots : [string, [string, string]][] ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>multiRobots : MultiSkilledRobot[] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot function getMultiRobots() { ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots : () => MultiSkilledRobot[] return multiRobots; ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] } for (let [, nameA] of robots) { > : undefined >nameA : string ->robots : [number, string, string][] +>robots : Robot[] console.log(nameA); >console.log(nameA) : void @@ -83,8 +83,8 @@ for (let [, nameA] of robots) { for (let [, nameA] of getRobots()) { > : undefined >nameA : string ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(nameA); >console.log(nameA) : void @@ -96,9 +96,9 @@ for (let [, nameA] of getRobots()) { for (let [, nameA] of [robotA, robotB]) { > : undefined >nameA : string ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(nameA); >console.log(nameA) : void @@ -111,7 +111,7 @@ for (let [, [primarySkillA, secondarySkillA]] of multiRobots) { > : undefined >primarySkillA : string >secondarySkillA : string ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(primarySkillA); >console.log(primarySkillA) : void @@ -124,8 +124,8 @@ for (let [, [primarySkillA, secondarySkillA]] of getMultiRobots()) { > : undefined >primarySkillA : string >secondarySkillA : string ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(primarySkillA); >console.log(primarySkillA) : void @@ -138,9 +138,9 @@ for (let [, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB]) { > : undefined >primarySkillA : string >secondarySkillA : string ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(primarySkillA); >console.log(primarySkillA) : void @@ -152,7 +152,7 @@ for (let [, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB]) { for (let [numberB] of robots) { >numberB : number ->robots : [number, string, string][] +>robots : Robot[] console.log(numberB); >console.log(numberB) : void @@ -163,8 +163,8 @@ for (let [numberB] of robots) { } for (let [numberB] of getRobots()) { >numberB : number ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(numberB); >console.log(numberB) : void @@ -175,9 +175,9 @@ for (let [numberB] of getRobots()) { } for (let [numberB] of [robotA, robotB]) { >numberB : number ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(numberB); >console.log(numberB) : void @@ -188,7 +188,7 @@ for (let [numberB] of [robotA, robotB]) { } for (let [nameB] of multiRobots) { >nameB : string ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(nameB); >console.log(nameB) : void @@ -199,8 +199,8 @@ for (let [nameB] of multiRobots) { } for (let [nameB] of getMultiRobots()) { >nameB : string ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(nameB); >console.log(nameB) : void @@ -211,9 +211,9 @@ for (let [nameB] of getMultiRobots()) { } for (let [nameB] of [multiRobotA, multiRobotB]) { >nameB : string ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(nameB); >console.log(nameB) : void @@ -227,7 +227,7 @@ for (let [numberA2, nameA2, skillA2] of robots) { >numberA2 : number >nameA2 : string >skillA2 : string ->robots : [number, string, string][] +>robots : Robot[] console.log(nameA2); >console.log(nameA2) : void @@ -240,8 +240,8 @@ for (let [numberA2, nameA2, skillA2] of getRobots()) { >numberA2 : number >nameA2 : string >skillA2 : string ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(nameA2); >console.log(nameA2) : void @@ -254,9 +254,9 @@ for (let [numberA2, nameA2, skillA2] of [robotA, robotB]) { >numberA2 : number >nameA2 : string >skillA2 : string ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(nameA2); >console.log(nameA2) : void @@ -269,7 +269,7 @@ for (let [nameMA, [primarySkillA, secondarySkillA]] of multiRobots) { >nameMA : string >primarySkillA : string >secondarySkillA : string ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(nameMA); >console.log(nameMA) : void @@ -282,8 +282,8 @@ for (let [nameMA, [primarySkillA, secondarySkillA]] of getMultiRobots()) { >nameMA : string >primarySkillA : string >secondarySkillA : string ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(nameMA); >console.log(nameMA) : void @@ -296,9 +296,9 @@ for (let [nameMA, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB >nameMA : string >primarySkillA : string >secondarySkillA : string ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(nameMA); >console.log(nameMA) : void @@ -311,7 +311,7 @@ for (let [nameMA, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB for (let [numberA3, ...robotAInfo] of robots) { >numberA3 : number >robotAInfo : [string, string] ->robots : [number, string, string][] +>robots : Robot[] console.log(numberA3); >console.log(numberA3) : void @@ -323,8 +323,8 @@ for (let [numberA3, ...robotAInfo] of robots) { for (let [numberA3, ...robotAInfo] of getRobots()) { >numberA3 : number >robotAInfo : [string, string] ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(numberA3); >console.log(numberA3) : void @@ -336,9 +336,9 @@ for (let [numberA3, ...robotAInfo] of getRobots()) { for (let [numberA3, ...robotAInfo] of [robotA, robotB]) { >numberA3 : number >robotAInfo : [string, string] ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(numberA3); >console.log(numberA3) : void @@ -349,7 +349,7 @@ for (let [numberA3, ...robotAInfo] of [robotA, robotB]) { } for (let [...multiRobotAInfo] of multiRobots) { >multiRobotAInfo : [string, [string, string]] ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(multiRobotAInfo); >console.log(multiRobotAInfo) : void @@ -360,8 +360,8 @@ for (let [...multiRobotAInfo] of multiRobots) { } for (let [...multiRobotAInfo] of getMultiRobots()) { >multiRobotAInfo : [string, [string, string]] ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(multiRobotAInfo); >console.log(multiRobotAInfo) : void @@ -372,9 +372,9 @@ for (let [...multiRobotAInfo] of getMultiRobots()) { } for (let [...multiRobotAInfo] of [multiRobotA, multiRobotB]) { >multiRobotAInfo : [string, [string, string]] ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(multiRobotAInfo); >console.log(multiRobotAInfo) : void diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern2.types index c6b57fb4f62da..92797377d3a49 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern2.types @@ -7,40 +7,40 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, [string, string]]; ->MultiSkilledRobot : [string, [string, string]] +>MultiSkilledRobot : MultiSkilledRobot let robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" let robotB: Robot = [2, "trimmer", "trimming"]; ->robotB : [number, string, string] +>robotB : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" >"trimming" : "trimming" let robots = [robotA, robotB]; ->robots : [number, string, string][] ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>robots : Robot[] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot function getRobots() { ->getRobots : () => [number, string, string][] +>getRobots : () => Robot[] return robots; ->robots : [number, string, string][] +>robots : Robot[] } let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, [string, string]] >"mower" : "mower" >["mowing", ""] : [string, string] @@ -48,7 +48,7 @@ let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -56,16 +56,16 @@ let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" let multiRobots = [multiRobotA, multiRobotB]; ->multiRobots : [string, [string, string]][] ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>multiRobots : MultiSkilledRobot[] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot function getMultiRobots() { ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots : () => MultiSkilledRobot[] return multiRobots; ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] } let nameA: string, primarySkillA: string, secondarySkillA: string; @@ -92,7 +92,7 @@ for ([, nameA] of robots) { >[, nameA] : [undefined, string] > : undefined >nameA : string ->robots : [number, string, string][] +>robots : Robot[] console.log(nameA); >console.log(nameA) : void @@ -105,8 +105,8 @@ for ([, nameA] of getRobots()) { >[, nameA] : [undefined, string] > : undefined >nameA : string ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(nameA); >console.log(nameA) : void @@ -119,9 +119,9 @@ for ([, nameA] of [robotA, robotB]) { >[, nameA] : [undefined, string] > : undefined >nameA : string ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(nameA); >console.log(nameA) : void @@ -136,7 +136,7 @@ for ([, [primarySkillA, secondarySkillA]] of multiRobots) { >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(primarySkillA); >console.log(primarySkillA) : void @@ -151,8 +151,8 @@ for ([, [primarySkillA, secondarySkillA]] of getMultiRobots()) { >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(primarySkillA); >console.log(primarySkillA) : void @@ -167,9 +167,9 @@ for ([, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB]) { >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(primarySkillA); >console.log(primarySkillA) : void @@ -182,7 +182,7 @@ for ([, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB]) { for ([numberB] of robots) { >[numberB] : [number] >numberB : number ->robots : [number, string, string][] +>robots : Robot[] console.log(numberB); >console.log(numberB) : void @@ -194,8 +194,8 @@ for ([numberB] of robots) { for ([numberB] of getRobots()) { >[numberB] : [number] >numberB : number ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(numberB); >console.log(numberB) : void @@ -207,9 +207,9 @@ for ([numberB] of getRobots()) { for ([numberB] of [robotA, robotB]) { >[numberB] : [number] >numberB : number ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(numberB); >console.log(numberB) : void @@ -221,7 +221,7 @@ for ([numberB] of [robotA, robotB]) { for ([nameB] of multiRobots) { >[nameB] : [string] >nameB : string ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(nameB); >console.log(nameB) : void @@ -233,8 +233,8 @@ for ([nameB] of multiRobots) { for ([nameB] of getMultiRobots()) { >[nameB] : [string] >nameB : string ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(nameB); >console.log(nameB) : void @@ -246,9 +246,9 @@ for ([nameB] of getMultiRobots()) { for ([nameB] of [multiRobotA, multiRobotB]) { >[nameB] : [string] >nameB : string ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(nameB); >console.log(nameB) : void @@ -263,7 +263,7 @@ for ([numberA2, nameA2, skillA2] of robots) { >numberA2 : number >nameA2 : string >skillA2 : string ->robots : [number, string, string][] +>robots : Robot[] console.log(nameA2); >console.log(nameA2) : void @@ -277,8 +277,8 @@ for ([numberA2, nameA2, skillA2] of getRobots()) { >numberA2 : number >nameA2 : string >skillA2 : string ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(nameA2); >console.log(nameA2) : void @@ -292,9 +292,9 @@ for ([numberA2, nameA2, skillA2] of [robotA, robotB]) { >numberA2 : number >nameA2 : string >skillA2 : string ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(nameA2); >console.log(nameA2) : void @@ -309,7 +309,7 @@ for ([nameMA, [primarySkillA, secondarySkillA]] of multiRobots) { >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(nameMA); >console.log(nameMA) : void @@ -324,8 +324,8 @@ for ([nameMA, [primarySkillA, secondarySkillA]] of getMultiRobots()) { >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(nameMA); >console.log(nameMA) : void @@ -340,9 +340,9 @@ for ([nameMA, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB]) { >[primarySkillA, secondarySkillA] : [string, string] >primarySkillA : string >secondarySkillA : string ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(nameMA); >console.log(nameMA) : void @@ -357,7 +357,7 @@ for ([numberA3, ...robotAInfo] of robots) { >numberA3 : number >...robotAInfo : string | number >robotAInfo : (string | number)[] ->robots : [number, string, string][] +>robots : Robot[] console.log(numberA3); >console.log(numberA3) : void @@ -371,8 +371,8 @@ for ([numberA3, ...robotAInfo] of getRobots()) { >numberA3 : number >...robotAInfo : string | number >robotAInfo : (string | number)[] ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(numberA3); >console.log(numberA3) : void @@ -386,9 +386,9 @@ for ([numberA3, ...robotAInfo] of [robotA, robotB]) { >numberA3 : number >...robotAInfo : string | number >robotAInfo : (string | number)[] ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(numberA3); >console.log(numberA3) : void @@ -401,7 +401,7 @@ for ([...multiRobotAInfo] of multiRobots) { >[...multiRobotAInfo] : (string | [string, string])[] >...multiRobotAInfo : string | [string, string] >multiRobotAInfo : (string | [string, string])[] ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(multiRobotAInfo); >console.log(multiRobotAInfo) : void @@ -414,8 +414,8 @@ for ([...multiRobotAInfo] of getMultiRobots()) { >[...multiRobotAInfo] : (string | [string, string])[] >...multiRobotAInfo : string | [string, string] >multiRobotAInfo : (string | [string, string])[] ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(multiRobotAInfo); >console.log(multiRobotAInfo) : void @@ -428,9 +428,9 @@ for ([...multiRobotAInfo] of [multiRobotA, multiRobotB]) { >[...multiRobotAInfo] : (string | [string, string])[] >...multiRobotAInfo : string | [string, string] >multiRobotAInfo : (string | [string, string])[] ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(multiRobotAInfo); >console.log(multiRobotAInfo) : void diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.types b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.types index 34689acf92089..cab4cc5ba07be 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.types @@ -7,40 +7,40 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, [string, string]]; ->MultiSkilledRobot : [string, [string, string]] +>MultiSkilledRobot : MultiSkilledRobot let robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" let robotB: Robot = [2, "trimmer", "trimming"]; ->robotB : [number, string, string] +>robotB : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" >"trimming" : "trimming" let robots = [robotA, robotB]; ->robots : [number, string, string][] ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>robots : Robot[] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot function getRobots() { ->getRobots : () => [number, string, string][] +>getRobots : () => Robot[] return robots; ->robots : [number, string, string][] +>robots : Robot[] } let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, [string, string]] >"mower" : "mower" >["mowing", ""] : [string, string] @@ -48,7 +48,7 @@ let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -56,23 +56,23 @@ let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" let multiRobots = [multiRobotA, multiRobotB]; ->multiRobots : [string, [string, string]][] ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>multiRobots : MultiSkilledRobot[] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot function getMultiRobots() { ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots : () => MultiSkilledRobot[] return multiRobots; ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] } for (let [, nameA = "noName"] of robots) { > : undefined >nameA : string >"noName" : "noName" ->robots : [number, string, string][] +>robots : Robot[] console.log(nameA); >console.log(nameA) : void @@ -85,8 +85,8 @@ for (let [, nameA = "noName"] of getRobots()) { > : undefined >nameA : string >"noName" : "noName" ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(nameA); >console.log(nameA) : void @@ -99,9 +99,9 @@ for (let [, nameA = "noName"] of [robotA, robotB]) { > : undefined >nameA : string >"noName" : "noName" ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(nameA); >console.log(nameA) : void @@ -125,7 +125,7 @@ for (let [, [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(primarySkillA); >console.log(primarySkillA) : void @@ -149,8 +149,8 @@ for (let [, [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(primarySkillA); >console.log(primarySkillA) : void @@ -174,9 +174,9 @@ for (let [, [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(primarySkillA); >console.log(primarySkillA) : void @@ -190,7 +190,7 @@ for (let [numberB = -1] of robots) { >numberB : number >-1 : -1 >1 : 1 ->robots : [number, string, string][] +>robots : Robot[] console.log(numberB); >console.log(numberB) : void @@ -203,8 +203,8 @@ for (let [numberB = -1] of getRobots()) { >numberB : number >-1 : -1 >1 : 1 ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(numberB); >console.log(numberB) : void @@ -217,9 +217,9 @@ for (let [numberB = -1] of [robotA, robotB]) { >numberB : number >-1 : -1 >1 : 1 ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(numberB); >console.log(numberB) : void @@ -231,7 +231,7 @@ for (let [numberB = -1] of [robotA, robotB]) { for (let [nameB = "noName"] of multiRobots) { >nameB : string >"noName" : "noName" ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(nameB); >console.log(nameB) : void @@ -243,8 +243,8 @@ for (let [nameB = "noName"] of multiRobots) { for (let [nameB = "noName"] of getMultiRobots()) { >nameB : string >"noName" : "noName" ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(nameB); >console.log(nameB) : void @@ -256,9 +256,9 @@ for (let [nameB = "noName"] of getMultiRobots()) { for (let [nameB = "noName"] of [multiRobotA, multiRobotB]) { >nameB : string >"noName" : "noName" ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(nameB); >console.log(nameB) : void @@ -276,7 +276,7 @@ for (let [numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of robots) { >"noName" : "noName" >skillA2 : string >"skill" : "skill" ->robots : [number, string, string][] +>robots : Robot[] console.log(nameA2); >console.log(nameA2) : void @@ -293,8 +293,8 @@ for (let [numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of getRobots()) { >"noName" : "noName" >skillA2 : string >"skill" : "skill" ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(nameA2); >console.log(nameA2) : void @@ -311,9 +311,9 @@ for (let [numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of [robotA, robot >"noName" : "noName" >skillA2 : string >"skill" : "skill" ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(nameA2); >console.log(nameA2) : void @@ -338,7 +338,7 @@ for (let [nameMA = "noName", [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(nameMA); >console.log(nameMA) : void @@ -363,8 +363,8 @@ for (let [nameMA = "noName", [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(nameMA); >console.log(nameMA) : void @@ -389,9 +389,9 @@ for (let [nameMA = "noName", [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(nameMA); >console.log(nameMA) : void @@ -406,7 +406,7 @@ for (let [numberA3 = -1, ...robotAInfo] of robots) { >-1 : -1 >1 : 1 >robotAInfo : [string, string] ->robots : [number, string, string][] +>robots : Robot[] console.log(numberA3); >console.log(numberA3) : void @@ -420,8 +420,8 @@ for (let [numberA3 = -1, ...robotAInfo] of getRobots()) { >-1 : -1 >1 : 1 >robotAInfo : [string, string] ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(numberA3); >console.log(numberA3) : void @@ -435,9 +435,9 @@ for (let [numberA3 = -1, ...robotAInfo] of [robotA, robotB]) { >-1 : -1 >1 : 1 >robotAInfo : [string, string] ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(numberA3); >console.log(numberA3) : void diff --git a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.types b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.types index ffca2d37c8945..14e0bbaa33580 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.types @@ -7,40 +7,40 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, [string, string]]; ->MultiSkilledRobot : [string, [string, string]] +>MultiSkilledRobot : MultiSkilledRobot let robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" let robotB: Robot = [2, "trimmer", "trimming"]; ->robotB : [number, string, string] +>robotB : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" >"trimming" : "trimming" let robots = [robotA, robotB]; ->robots : [number, string, string][] ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>robots : Robot[] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot function getRobots() { ->getRobots : () => [number, string, string][] +>getRobots : () => Robot[] return robots; ->robots : [number, string, string][] +>robots : Robot[] } let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, [string, string]] >"mower" : "mower" >["mowing", ""] : [string, string] @@ -48,7 +48,7 @@ let multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -56,16 +56,16 @@ let multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" let multiRobots = [multiRobotA, multiRobotB]; ->multiRobots : [string, [string, string]][] ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>multiRobots : MultiSkilledRobot[] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot function getMultiRobots() { ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots : () => MultiSkilledRobot[] return multiRobots; ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] } let nameA: string, primarySkillA: string, secondarySkillA: string; @@ -94,7 +94,7 @@ for ([, nameA = "noName"] of robots) { >nameA = "noName" : "noName" >nameA : string >"noName" : "noName" ->robots : [number, string, string][] +>robots : Robot[] console.log(nameA); >console.log(nameA) : void @@ -109,8 +109,8 @@ for ([, nameA = "noName"] of getRobots()) { >nameA = "noName" : "noName" >nameA : string >"noName" : "noName" ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(nameA); >console.log(nameA) : void @@ -125,9 +125,9 @@ for ([, nameA = "noName"] of [robotA, robotB]) { >nameA = "noName" : "noName" >nameA : string >"noName" : "noName" ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(nameA); >console.log(nameA) : void @@ -156,7 +156,7 @@ for ([, [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(primarySkillA); >console.log(primarySkillA) : void @@ -185,8 +185,8 @@ for ([, [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(primarySkillA); >console.log(primarySkillA) : void @@ -215,9 +215,9 @@ for ([, [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(primarySkillA); >console.log(primarySkillA) : void @@ -233,7 +233,7 @@ for ([numberB = -1] of robots) { >numberB : number >-1 : -1 >1 : 1 ->robots : [number, string, string][] +>robots : Robot[] console.log(numberB); >console.log(numberB) : void @@ -248,8 +248,8 @@ for ([numberB = -1] of getRobots()) { >numberB : number >-1 : -1 >1 : 1 ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(numberB); >console.log(numberB) : void @@ -264,9 +264,9 @@ for ([numberB = -1] of [robotA, robotB]) { >numberB : number >-1 : -1 >1 : 1 ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(numberB); >console.log(numberB) : void @@ -280,7 +280,7 @@ for ([nameB = "noName"] of multiRobots) { >nameB = "noName" : "noName" >nameB : string >"noName" : "noName" ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(nameB); >console.log(nameB) : void @@ -294,8 +294,8 @@ for ([nameB = "noName"] of getMultiRobots()) { >nameB = "noName" : "noName" >nameB : string >"noName" : "noName" ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(nameB); >console.log(nameB) : void @@ -309,9 +309,9 @@ for ([nameB = "noName"] of [multiRobotA, multiRobotB]) { >nameB = "noName" : "noName" >nameB : string >"noName" : "noName" ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(nameB); >console.log(nameB) : void @@ -333,7 +333,7 @@ for ([numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of robots) { >skillA2 = "skill" : "skill" >skillA2 : string >"skill" : "skill" ->robots : [number, string, string][] +>robots : Robot[] console.log(nameA2); >console.log(nameA2) : void @@ -354,8 +354,8 @@ for ([numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of getRobots()) { >skillA2 = "skill" : "skill" >skillA2 : string >"skill" : "skill" ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(nameA2); >console.log(nameA2) : void @@ -376,9 +376,9 @@ for ([numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of [robotA, robotB]) >skillA2 = "skill" : "skill" >skillA2 : string >"skill" : "skill" ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(nameA2); >console.log(nameA2) : void @@ -409,7 +409,7 @@ for ([nameMA = "noName", [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->multiRobots : [string, [string, string]][] +>multiRobots : MultiSkilledRobot[] console.log(nameMA); >console.log(nameMA) : void @@ -440,8 +440,8 @@ for ([nameMA = "noName", [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->getMultiRobots() : [string, [string, string]][] ->getMultiRobots : () => [string, [string, string]][] +>getMultiRobots() : MultiSkilledRobot[] +>getMultiRobots : () => MultiSkilledRobot[] console.log(nameMA); >console.log(nameMA) : void @@ -472,9 +472,9 @@ for ([nameMA = "noName", [ >["skill1", "skill2"] : [string, string] >"skill1" : "skill1" >"skill2" : "skill2" ->[multiRobotA, multiRobotB] : [string, [string, string]][] ->multiRobotA : [string, [string, string]] ->multiRobotB : [string, [string, string]] +>[multiRobotA, multiRobotB] : MultiSkilledRobot[] +>multiRobotA : MultiSkilledRobot +>multiRobotB : MultiSkilledRobot console.log(nameMA); >console.log(nameMA) : void @@ -492,7 +492,7 @@ for ([numberA3 = -1, ...robotAInfo] of robots) { >1 : 1 >...robotAInfo : string | number >robotAInfo : (string | number)[] ->robots : [number, string, string][] +>robots : Robot[] console.log(numberA3); >console.log(numberA3) : void @@ -509,8 +509,8 @@ for ([numberA3 = -1, ...robotAInfo] of getRobots()) { >1 : 1 >...robotAInfo : string | number >robotAInfo : (string | number)[] ->getRobots() : [number, string, string][] ->getRobots : () => [number, string, string][] +>getRobots() : Robot[] +>getRobots : () => Robot[] console.log(numberA3); >console.log(numberA3) : void @@ -527,9 +527,9 @@ for ([numberA3 = -1, ...robotAInfo] of [robotA, robotB]) { >1 : 1 >...robotAInfo : string | number >robotAInfo : (string | number)[] ->[robotA, robotB] : [number, string, string][] ->robotA : [number, string, string] ->robotB : [number, string, string] +>[robotA, robotB] : Robot[] +>robotA : Robot +>robotB : Robot console.log(numberA3); >console.log(numberA3) : void diff --git a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern.types b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern.types index 2758457edbe7a..ff955abe34bfe 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern.types @@ -7,17 +7,17 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot var robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" function foo1([, nameA]: Robot) { ->foo1 : ([, nameA]: [number, string, string]) => void +>foo1 : ([, nameA]: Robot) => void > : undefined >nameA : string @@ -30,7 +30,7 @@ function foo1([, nameA]: Robot) { } function foo2([numberB]: Robot) { ->foo2 : ([numberB]: [number, string, string]) => void +>foo2 : ([numberB]: Robot) => void >numberB : number console.log(numberB); @@ -42,7 +42,7 @@ function foo2([numberB]: Robot) { } function foo3([numberA2, nameA2, skillA2]: Robot) { ->foo3 : ([numberA2, nameA2, skillA2]: [number, string, string]) => void +>foo3 : ([numberA2, nameA2, skillA2]: Robot) => void >numberA2 : number >nameA2 : string >skillA2 : string @@ -56,7 +56,7 @@ function foo3([numberA2, nameA2, skillA2]: Robot) { } function foo4([numberA3, ...robotAInfo]: Robot) { ->foo4 : ([numberA3, ...robotAInfo]: [number, string, string]) => void +>foo4 : ([numberA3, ...robotAInfo]: Robot) => void >numberA3 : number >robotAInfo : [string, string] @@ -70,12 +70,12 @@ function foo4([numberA3, ...robotAInfo]: Robot) { foo1(robotA); >foo1(robotA) : void ->foo1 : ([, nameA]: [number, string, string]) => void ->robotA : [number, string, string] +>foo1 : ([, nameA]: Robot) => void +>robotA : Robot foo1([2, "trimmer", "trimming"]); >foo1([2, "trimmer", "trimming"]) : void ->foo1 : ([, nameA]: [number, string, string]) => void +>foo1 : ([, nameA]: Robot) => void >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -83,12 +83,12 @@ foo1([2, "trimmer", "trimming"]); foo2(robotA); >foo2(robotA) : void ->foo2 : ([numberB]: [number, string, string]) => void ->robotA : [number, string, string] +>foo2 : ([numberB]: Robot) => void +>robotA : Robot foo2([2, "trimmer", "trimming"]); >foo2([2, "trimmer", "trimming"]) : void ->foo2 : ([numberB]: [number, string, string]) => void +>foo2 : ([numberB]: Robot) => void >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -96,12 +96,12 @@ foo2([2, "trimmer", "trimming"]); foo3(robotA); >foo3(robotA) : void ->foo3 : ([numberA2, nameA2, skillA2]: [number, string, string]) => void ->robotA : [number, string, string] +>foo3 : ([numberA2, nameA2, skillA2]: Robot) => void +>robotA : Robot foo3([2, "trimmer", "trimming"]); >foo3([2, "trimmer", "trimming"]) : void ->foo3 : ([numberA2, nameA2, skillA2]: [number, string, string]) => void +>foo3 : ([numberA2, nameA2, skillA2]: Robot) => void >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -109,12 +109,12 @@ foo3([2, "trimmer", "trimming"]); foo4(robotA); >foo4(robotA) : void ->foo4 : ([numberA3, ...robotAInfo]: [number, string, string]) => void ->robotA : [number, string, string] +>foo4 : ([numberA3, ...robotAInfo]: Robot) => void +>robotA : Robot foo4([2, "trimmer", "trimming"]); >foo4([2, "trimmer", "trimming"]) : void ->foo4 : ([numberA3, ...robotAInfo]: [number, string, string]) => void +>foo4 : ([numberA3, ...robotAInfo]: Robot) => void >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" diff --git a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern2.types index 1cdced45404f3..aee226f8d837a 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern2.types @@ -7,10 +7,10 @@ declare var console: { >msg : any } type Robot = [string, [string, string]]; ->Robot : [string, [string, string]] +>Robot : Robot var robotA: Robot = ["trimmer", ["trimming", "edging"]]; ->robotA : [string, [string, string]] +>robotA : Robot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -18,7 +18,7 @@ var robotA: Robot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" function foo1([, skillA]: Robot) { ->foo1 : ([, skillA]: [string, [string, string]]) => void +>foo1 : ([, skillA]: Robot) => void > : undefined >skillA : [string, string] @@ -31,7 +31,7 @@ function foo1([, skillA]: Robot) { } function foo2([nameMB]: Robot) { ->foo2 : ([nameMB]: [string, [string, string]]) => void +>foo2 : ([nameMB]: Robot) => void >nameMB : string console.log(nameMB); @@ -43,7 +43,7 @@ function foo2([nameMB]: Robot) { } function foo3([nameMA, [primarySkillA, secondarySkillA]]: Robot) { ->foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: [string, [string, string]]) => void +>foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: Robot) => void >nameMA : string >primarySkillA : string >secondarySkillA : string @@ -57,7 +57,7 @@ function foo3([nameMA, [primarySkillA, secondarySkillA]]: Robot) { } function foo4([...multiRobotAInfo]: Robot) { ->foo4 : ([...multiRobotAInfo]: [string, [string, string]]) => void +>foo4 : ([...multiRobotAInfo]: Robot) => void >multiRobotAInfo : [string, [string, string]] console.log(multiRobotAInfo); @@ -70,12 +70,12 @@ function foo4([...multiRobotAInfo]: Robot) { foo1(robotA); >foo1(robotA) : void ->foo1 : ([, skillA]: [string, [string, string]]) => void ->robotA : [string, [string, string]] +>foo1 : ([, skillA]: Robot) => void +>robotA : Robot foo1(["roomba", ["vaccum", "mopping"]]); >foo1(["roomba", ["vaccum", "mopping"]]) : void ->foo1 : ([, skillA]: [string, [string, string]]) => void +>foo1 : ([, skillA]: Robot) => void >["roomba", ["vaccum", "mopping"]] : [string, [string, string]] >"roomba" : "roomba" >["vaccum", "mopping"] : [string, string] @@ -84,12 +84,12 @@ foo1(["roomba", ["vaccum", "mopping"]]); foo2(robotA); >foo2(robotA) : void ->foo2 : ([nameMB]: [string, [string, string]]) => void ->robotA : [string, [string, string]] +>foo2 : ([nameMB]: Robot) => void +>robotA : Robot foo2(["roomba", ["vaccum", "mopping"]]); >foo2(["roomba", ["vaccum", "mopping"]]) : void ->foo2 : ([nameMB]: [string, [string, string]]) => void +>foo2 : ([nameMB]: Robot) => void >["roomba", ["vaccum", "mopping"]] : [string, [string, string]] >"roomba" : "roomba" >["vaccum", "mopping"] : [string, string] @@ -98,12 +98,12 @@ foo2(["roomba", ["vaccum", "mopping"]]); foo3(robotA); >foo3(robotA) : void ->foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: [string, [string, string]]) => void ->robotA : [string, [string, string]] +>foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: Robot) => void +>robotA : Robot foo3(["roomba", ["vaccum", "mopping"]]); >foo3(["roomba", ["vaccum", "mopping"]]) : void ->foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: [string, [string, string]]) => void +>foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: Robot) => void >["roomba", ["vaccum", "mopping"]] : [string, [string, string]] >"roomba" : "roomba" >["vaccum", "mopping"] : [string, string] @@ -112,12 +112,12 @@ foo3(["roomba", ["vaccum", "mopping"]]); foo4(robotA); >foo4(robotA) : void ->foo4 : ([...multiRobotAInfo]: [string, [string, string]]) => void ->robotA : [string, [string, string]] +>foo4 : ([...multiRobotAInfo]: Robot) => void +>robotA : Robot foo4(["roomba", ["vaccum", "mopping"]]); >foo4(["roomba", ["vaccum", "mopping"]]) : void ->foo4 : ([...multiRobotAInfo]: [string, [string, string]]) => void +>foo4 : ([...multiRobotAInfo]: Robot) => void >["roomba", ["vaccum", "mopping"]] : [string, [string, string]] >"roomba" : "roomba" >["vaccum", "mopping"] : [string, string] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types index 60345aa2b73c4..94106255a1290 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types @@ -7,17 +7,17 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot var robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" function foo1([, nameA = "noName"]: Robot = [-1, "name", "skill"]) { ->foo1 : ([, nameA]?: [number, string, string]) => void +>foo1 : ([, nameA]?: Robot) => void > : undefined >nameA : string >"noName" : "noName" @@ -36,7 +36,7 @@ function foo1([, nameA = "noName"]: Robot = [-1, "name", "skill"]) { } function foo2([numberB = -1]: Robot = [-1, "name", "skill"]) { ->foo2 : ([numberB]?: [number, string, string]) => void +>foo2 : ([numberB]?: Robot) => void >numberB : number >-1 : -1 >1 : 1 @@ -55,7 +55,7 @@ function foo2([numberB = -1]: Robot = [-1, "name", "skill"]) { } function foo3([numberA2 = -1, nameA2 = "name", skillA2 = "skill"]: Robot = [-1, "name", "skill"]) { ->foo3 : ([numberA2, nameA2, skillA2]?: [number, string, string]) => void +>foo3 : ([numberA2, nameA2, skillA2]?: Robot) => void >numberA2 : number >-1 : -1 >1 : 1 @@ -78,7 +78,7 @@ function foo3([numberA2 = -1, nameA2 = "name", skillA2 = "skill"]: Robot = [-1, } function foo4([numberA3 = -1, ...robotAInfo]: Robot = [-1, "name", "skill"]) { ->foo4 : ([numberA3, ...robotAInfo]?: [number, string, string]) => void +>foo4 : ([numberA3, ...robotAInfo]?: Robot) => void >numberA3 : number >-1 : -1 >1 : 1 @@ -99,12 +99,12 @@ function foo4([numberA3 = -1, ...robotAInfo]: Robot = [-1, "name", "skill"]) { foo1(robotA); >foo1(robotA) : void ->foo1 : ([, nameA]?: [number, string, string]) => void ->robotA : [number, string, string] +>foo1 : ([, nameA]?: Robot) => void +>robotA : Robot foo1([2, "trimmer", "trimming"]); >foo1([2, "trimmer", "trimming"]) : void ->foo1 : ([, nameA]?: [number, string, string]) => void +>foo1 : ([, nameA]?: Robot) => void >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -112,12 +112,12 @@ foo1([2, "trimmer", "trimming"]); foo2(robotA); >foo2(robotA) : void ->foo2 : ([numberB]?: [number, string, string]) => void ->robotA : [number, string, string] +>foo2 : ([numberB]?: Robot) => void +>robotA : Robot foo2([2, "trimmer", "trimming"]); >foo2([2, "trimmer", "trimming"]) : void ->foo2 : ([numberB]?: [number, string, string]) => void +>foo2 : ([numberB]?: Robot) => void >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -125,12 +125,12 @@ foo2([2, "trimmer", "trimming"]); foo3(robotA); >foo3(robotA) : void ->foo3 : ([numberA2, nameA2, skillA2]?: [number, string, string]) => void ->robotA : [number, string, string] +>foo3 : ([numberA2, nameA2, skillA2]?: Robot) => void +>robotA : Robot foo3([2, "trimmer", "trimming"]); >foo3([2, "trimmer", "trimming"]) : void ->foo3 : ([numberA2, nameA2, skillA2]?: [number, string, string]) => void +>foo3 : ([numberA2, nameA2, skillA2]?: Robot) => void >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -138,12 +138,12 @@ foo3([2, "trimmer", "trimming"]); foo4(robotA); >foo4(robotA) : void ->foo4 : ([numberA3, ...robotAInfo]?: [number, string, string]) => void ->robotA : [number, string, string] +>foo4 : ([numberA3, ...robotAInfo]?: Robot) => void +>robotA : Robot foo4([2, "trimmer", "trimming"]); >foo4([2, "trimmer", "trimming"]) : void ->foo4 : ([numberA3, ...robotAInfo]?: [number, string, string]) => void +>foo4 : ([numberA3, ...robotAInfo]?: Robot) => void >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" diff --git a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types index d9c991f65fb87..f2773f2d25212 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types @@ -7,10 +7,10 @@ declare var console: { >msg : any } type Robot = [string, string[]]; ->Robot : [string, string[]] +>Robot : Robot var robotA: Robot = ["trimmer", ["trimming", "edging"]]; ->robotA : [string, string[]] +>robotA : Robot >["trimmer", ["trimming", "edging"]] : [string, string[]] >"trimmer" : "trimmer" >["trimming", "edging"] : string[] @@ -18,7 +18,7 @@ var robotA: Robot = ["trimmer", ["trimming", "edging"]]; >"edging" : "edging" function foo1([, skillA = ["noSkill", "noSkill"]]: Robot= ["name", ["skill1", "skill2"]]) { ->foo1 : ([, skillA]?: [string, string[]]) => void +>foo1 : ([, skillA]?: Robot) => void > : undefined >skillA : string[] >["noSkill", "noSkill"] : string[] @@ -39,7 +39,7 @@ function foo1([, skillA = ["noSkill", "noSkill"]]: Robot= ["name", ["skill1", "s } function foo2([nameMB = "noName"]: Robot = ["name", ["skill1", "skill2"]]) { ->foo2 : ([nameMB]?: [string, string[]]) => void +>foo2 : ([nameMB]?: Robot) => void >nameMB : string >"noName" : "noName" >["name", ["skill1", "skill2"]] : [string, string[]] @@ -57,7 +57,7 @@ function foo2([nameMB = "noName"]: Robot = ["name", ["skill1", "skill2"]]) { } function foo3([nameMA = "noName", [ ->foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: [string, string[]]) => void +>foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: Robot) => void >nameMA : string >"noName" : "noName" @@ -84,12 +84,12 @@ function foo3([nameMA = "noName", [ foo1(robotA); >foo1(robotA) : void ->foo1 : ([, skillA]?: [string, string[]]) => void ->robotA : [string, string[]] +>foo1 : ([, skillA]?: Robot) => void +>robotA : Robot foo1(["roomba", ["vaccum", "mopping"]]); >foo1(["roomba", ["vaccum", "mopping"]]) : void ->foo1 : ([, skillA]?: [string, string[]]) => void +>foo1 : ([, skillA]?: Robot) => void >["roomba", ["vaccum", "mopping"]] : [string, string[]] >"roomba" : "roomba" >["vaccum", "mopping"] : string[] @@ -98,12 +98,12 @@ foo1(["roomba", ["vaccum", "mopping"]]); foo2(robotA); >foo2(robotA) : void ->foo2 : ([nameMB]?: [string, string[]]) => void ->robotA : [string, string[]] +>foo2 : ([nameMB]?: Robot) => void +>robotA : Robot foo2(["roomba", ["vaccum", "mopping"]]); >foo2(["roomba", ["vaccum", "mopping"]]) : void ->foo2 : ([nameMB]?: [string, string[]]) => void +>foo2 : ([nameMB]?: Robot) => void >["roomba", ["vaccum", "mopping"]] : [string, string[]] >"roomba" : "roomba" >["vaccum", "mopping"] : string[] @@ -112,12 +112,12 @@ foo2(["roomba", ["vaccum", "mopping"]]); foo3(robotA); >foo3(robotA) : void ->foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: [string, string[]]) => void ->robotA : [string, string[]] +>foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: Robot) => void +>robotA : Robot foo3(["roomba", ["vaccum", "mopping"]]); >foo3(["roomba", ["vaccum", "mopping"]]) : void ->foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: [string, string[]]) => void +>foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: Robot) => void >["roomba", ["vaccum", "mopping"]] : [string, string[]] >"roomba" : "roomba" >["vaccum", "mopping"] : string[] diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.types index 2ed0777aa80b2..61e7f7ab3e2e9 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern.types @@ -7,17 +7,17 @@ declare var console: { >msg : string } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot var robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" var robotB: Robot = [2, "trimmer", "trimming"]; ->robotB : [number, string, string] +>robotB : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -27,17 +27,17 @@ var robotB: Robot = [2, "trimmer", "trimming"]; let [, nameA] = robotA; > : undefined >nameA : string ->robotA : [number, string, string] +>robotA : Robot let [numberB] = robotB; >numberB : number ->robotB : [number, string, string] +>robotB : Robot let [numberA2, nameA2, skillA2] = robotA; >numberA2 : number >nameA2 : string >skillA2 : string ->robotA : [number, string, string] +>robotA : Robot let [numberC2] = [3, "edging", "Trimming edges"]; >numberC2 : number @@ -58,7 +58,7 @@ let [numberC, nameC, skillC] = [3, "edging", "Trimming edges"]; let [numberA3, ...robotAInfo] = robotA; >numberA3 : number >robotAInfo : [string, string] ->robotA : [number, string, string] +>robotA : Robot if (nameA == nameA2) { >nameA == nameA2 : boolean diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.types index 94b0ff295a200..9027e3be1960b 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern2.types @@ -7,10 +7,10 @@ declare var console: { >msg : string } type MultiSkilledRobot = [string, [string, string]]; ->MultiSkilledRobot : [string, [string, string]] +>MultiSkilledRobot : MultiSkilledRobot var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, [string, string]] >"mower" : "mower" >["mowing", ""] : [string, string] @@ -18,7 +18,7 @@ var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" var multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -28,17 +28,17 @@ var multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; let [, skillA] = multiRobotA; > : undefined >skillA : [string, string] ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot let [nameMB] = multiRobotB; >nameMB : string ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot let [nameMA, [primarySkillA, secondarySkillA]] = multiRobotA; >nameMA : string >primarySkillA : string >secondarySkillA : string ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot let [nameMC] = ["roomba", ["vaccum", "mopping"]]; >nameMC : string @@ -60,7 +60,7 @@ let [nameMC2, [primarySkillC, secondarySkillC]] = ["roomba", ["vaccum", "mopping let [...multiRobotAInfo] = multiRobotA; >multiRobotAInfo : [string, [string, string]] ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot if (nameMB == nameMA) { >nameMB == nameMA : boolean diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.types index 10025aabc0ac9..1ee682f838a97 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPattern3.types @@ -7,27 +7,27 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, [string, string]]; ->MultiSkilledRobot : [string, [string, string]] +>MultiSkilledRobot : MultiSkilledRobot var robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" var robotB: Robot = [2, "trimmer", "trimming"]; ->robotB : [number, string, string] +>robotB : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" >"trimming" : "trimming" var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, [string, string]] >"mower" : "mower" >["mowing", ""] : [string, string] @@ -35,7 +35,7 @@ var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" var multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, [string, string]] >"trimmer" : "trimmer" >["trimming", "edging"] : [string, string] @@ -61,19 +61,19 @@ let multiRobotAInfo: (string | [string, string])[]; >multiRobotAInfo : (string | [string, string])[] [, nameA] = robotA; ->[, nameA] = robotA : [number, string, string] +>[, nameA] = robotA : Robot >[, nameA] : [undefined, string] > : undefined >nameA : string ->robotA : [number, string, string] +>robotA : Robot [, nameB] = getRobotB(); ->[, nameB] = getRobotB() : [number, string, string] +>[, nameB] = getRobotB() : Robot >[, nameB] : [undefined, string] > : undefined >nameB : string ->getRobotB() : [number, string, string] ->getRobotB : () => [number, string, string] +>getRobotB() : Robot +>getRobotB : () => Robot [, nameB] = [2, "trimmer", "trimming"]; >[, nameB] = [2, "trimmer", "trimming"] : [number, string, string] @@ -86,19 +86,19 @@ let multiRobotAInfo: (string | [string, string])[]; >"trimming" : "trimming" [, multiSkillB] = multiRobotB; ->[, multiSkillB] = multiRobotB : [string, [string, string]] +>[, multiSkillB] = multiRobotB : MultiSkilledRobot >[, multiSkillB] : [undefined, [string, string]] > : undefined >multiSkillB : [string, string] ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot [, multiSkillB] = getMultiRobotB(); ->[, multiSkillB] = getMultiRobotB() : [string, [string, string]] +>[, multiSkillB] = getMultiRobotB() : MultiSkilledRobot >[, multiSkillB] : [undefined, [string, string]] > : undefined >multiSkillB : [string, string] ->getMultiRobotB() : [string, [string, string]] ->getMultiRobotB : () => [string, [string, string]] +>getMultiRobotB() : MultiSkilledRobot +>getMultiRobotB : () => MultiSkilledRobot [, multiSkillB] = ["roomba", ["vaccum", "mopping"]]; >[, multiSkillB] = ["roomba", ["vaccum", "mopping"]] : [string, [string, string]] @@ -112,17 +112,17 @@ let multiRobotAInfo: (string | [string, string])[]; >"mopping" : "mopping" [numberB] = robotB; ->[numberB] = robotB : [number, string, string] +>[numberB] = robotB : Robot >[numberB] : [number] >numberB : number ->robotB : [number, string, string] +>robotB : Robot [numberB] = getRobotB(); ->[numberB] = getRobotB() : [number, string, string] +>[numberB] = getRobotB() : Robot >[numberB] : [number] >numberB : number ->getRobotB() : [number, string, string] ->getRobotB : () => [number, string, string] +>getRobotB() : Robot +>getRobotB : () => Robot [numberB] = [2, "trimmer", "trimming"]; >[numberB] = [2, "trimmer", "trimming"] : [number, string, string] @@ -134,17 +134,17 @@ let multiRobotAInfo: (string | [string, string])[]; >"trimming" : "trimming" [nameMB] = multiRobotB; ->[nameMB] = multiRobotB : [string, [string, string]] +>[nameMB] = multiRobotB : MultiSkilledRobot >[nameMB] : [string] >nameMB : string ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot [nameMB] = getMultiRobotB(); ->[nameMB] = getMultiRobotB() : [string, [string, string]] +>[nameMB] = getMultiRobotB() : MultiSkilledRobot >[nameMB] : [string] >nameMB : string ->getMultiRobotB() : [string, [string, string]] ->getMultiRobotB : () => [string, [string, string]] +>getMultiRobotB() : MultiSkilledRobot +>getMultiRobotB : () => MultiSkilledRobot [nameMB] = ["trimmer", ["trimming", "edging"]]; >[nameMB] = ["trimmer", ["trimming", "edging"]] : [string, string[]] @@ -157,21 +157,21 @@ let multiRobotAInfo: (string | [string, string])[]; >"edging" : "edging" [numberB, nameB, skillB] = robotB; ->[numberB, nameB, skillB] = robotB : [number, string, string] +>[numberB, nameB, skillB] = robotB : Robot >[numberB, nameB, skillB] : [number, string, string] >numberB : number >nameB : string >skillB : string ->robotB : [number, string, string] +>robotB : Robot [numberB, nameB, skillB] = getRobotB(); ->[numberB, nameB, skillB] = getRobotB() : [number, string, string] +>[numberB, nameB, skillB] = getRobotB() : Robot >[numberB, nameB, skillB] : [number, string, string] >numberB : number >nameB : string >skillB : string ->getRobotB() : [number, string, string] ->getRobotB : () => [number, string, string] +>getRobotB() : Robot +>getRobotB : () => Robot [numberB, nameB, skillB] = [2, "trimmer", "trimming"]; >[numberB, nameB, skillB] = [2, "trimmer", "trimming"] : [number, string, string] @@ -185,23 +185,23 @@ let multiRobotAInfo: (string | [string, string])[]; >"trimming" : "trimming" [nameMB, [primarySkillB, secondarySkillB]] = multiRobotB; ->[nameMB, [primarySkillB, secondarySkillB]] = multiRobotB : [string, [string, string]] +>[nameMB, [primarySkillB, secondarySkillB]] = multiRobotB : MultiSkilledRobot >[nameMB, [primarySkillB, secondarySkillB]] : [string, [string, string]] >nameMB : string >[primarySkillB, secondarySkillB] : [string, string] >primarySkillB : string >secondarySkillB : string ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot [nameMB, [primarySkillB, secondarySkillB]] = getMultiRobotB(); ->[nameMB, [primarySkillB, secondarySkillB]] = getMultiRobotB() : [string, [string, string]] +>[nameMB, [primarySkillB, secondarySkillB]] = getMultiRobotB() : MultiSkilledRobot >[nameMB, [primarySkillB, secondarySkillB]] : [string, [string, string]] >nameMB : string >[primarySkillB, secondarySkillB] : [string, string] >primarySkillB : string >secondarySkillB : string ->getMultiRobotB() : [string, [string, string]] ->getMultiRobotB : () => [string, [string, string]] +>getMultiRobotB() : MultiSkilledRobot +>getMultiRobotB : () => MultiSkilledRobot [nameMB, [primarySkillB, secondarySkillB]] = ["trimmer", ["trimming", "edging"]]; >[nameMB, [primarySkillB, secondarySkillB]] = ["trimmer", ["trimming", "edging"]] : [string, [string, string]] @@ -217,48 +217,48 @@ let multiRobotAInfo: (string | [string, string])[]; >"edging" : "edging" [numberB, ...robotAInfo] = robotB; ->[numberB, ...robotAInfo] = robotB : [number, string, string] +>[numberB, ...robotAInfo] = robotB : Robot >[numberB, ...robotAInfo] : [number, ...(string | number)[]] >numberB : number >...robotAInfo : string | number >robotAInfo : (string | number)[] ->robotB : [number, string, string] +>robotB : Robot [numberB, ...robotAInfo] = getRobotB(); ->[numberB, ...robotAInfo] = getRobotB() : [number, string, string] +>[numberB, ...robotAInfo] = getRobotB() : Robot >[numberB, ...robotAInfo] : [number, ...(string | number)[]] >numberB : number >...robotAInfo : string | number >robotAInfo : (string | number)[] ->getRobotB() : [number, string, string] ->getRobotB : () => [number, string, string] +>getRobotB() : Robot +>getRobotB : () => Robot [numberB, ...robotAInfo] = [2, "trimmer", "trimming"]; ->[numberB, ...robotAInfo] = [2, "trimmer", "trimming"] : [number, string, string] +>[numberB, ...robotAInfo] = [2, "trimmer", "trimming"] : Robot >[numberB, ...robotAInfo] : [number, ...(string | number)[]] >numberB : number >...robotAInfo : string | number >robotAInfo : (string | number)[] ->[2, "trimmer", "trimming"] : [number, string, string] +>[2, "trimmer", "trimming"] : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" >"trimming" : "trimming" [...multiRobotAInfo] = multiRobotA; ->[...multiRobotAInfo] = multiRobotA : [string, [string, string]] +>[...multiRobotAInfo] = multiRobotA : MultiSkilledRobot >[...multiRobotAInfo] : (string | [string, string])[] >...multiRobotAInfo : string | [string, string] >multiRobotAInfo : (string | [string, string])[] ->multiRobotA : [string, [string, string]] +>multiRobotA : MultiSkilledRobot [...multiRobotAInfo] = getMultiRobotB(); ->[...multiRobotAInfo] = getMultiRobotB() : [string, [string, string]] +>[...multiRobotAInfo] = getMultiRobotB() : MultiSkilledRobot >[...multiRobotAInfo] : (string | [string, string])[] >...multiRobotAInfo : string | [string, string] >multiRobotAInfo : (string | [string, string])[] ->getMultiRobotB() : [string, [string, string]] ->getMultiRobotB : () => [string, [string, string]] +>getMultiRobotB() : MultiSkilledRobot +>getMultiRobotB : () => MultiSkilledRobot [...multiRobotAInfo] = ["trimmer", ["trimming", "edging"]]; >[...multiRobotAInfo] = ["trimmer", ["trimming", "edging"]] : (string | [string, string])[] @@ -285,15 +285,15 @@ if (nameA == nameB) { } function getRobotB() { ->getRobotB : () => [number, string, string] +>getRobotB : () => Robot return robotB; ->robotB : [number, string, string] +>robotB : Robot } function getMultiRobotB() { ->getMultiRobotB : () => [string, [string, string]] +>getMultiRobotB : () => MultiSkilledRobot return multiRobotB; ->multiRobotB : [string, [string, string]] +>multiRobotB : MultiSkilledRobot } diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.types index 7e4ae19d39494..0bdf495f09efc 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues.types @@ -7,17 +7,17 @@ declare var console: { >msg : string } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot var robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" var robotB: Robot = [2, "trimmer", "trimming"]; ->robotB : [number, string, string] +>robotB : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -27,13 +27,13 @@ let [, nameA = "noName"] = robotA; > : undefined >nameA : string >"noName" : "noName" ->robotA : [number, string, string] +>robotA : Robot let [numberB = -1] = robotB; >numberB : number >-1 : -1 >1 : 1 ->robotB : [number, string, string] +>robotB : Robot let [numberA2 = -1, nameA2 = "noName", skillA2 = "noSkill"] = robotA; >numberA2 : number @@ -43,7 +43,7 @@ let [numberA2 = -1, nameA2 = "noName", skillA2 = "noSkill"] = robotA; >"noName" : "noName" >skillA2 : string >"noSkill" : "noSkill" ->robotA : [number, string, string] +>robotA : Robot let [numberC2 = -1] = [3, "edging", "Trimming edges"]; >numberC2 : number @@ -72,7 +72,7 @@ let [numberA3 = -1, ...robotAInfo] = robotA; >-1 : -1 >1 : 1 >robotAInfo : [string, string] ->robotA : [number, string, string] +>robotA : Robot if (nameA == nameA2) { >nameA == nameA2 : boolean diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.types index 3781d10d0696d..44fbba0b1ade2 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues2.types @@ -7,10 +7,10 @@ declare var console: { >msg : string } type MultiSkilledRobot = [string, string[]]; ->MultiSkilledRobot : [string, string[]] +>MultiSkilledRobot : MultiSkilledRobot var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, string[]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, string[]] >"mower" : "mower" >["mowing", ""] : string[] @@ -18,7 +18,7 @@ var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" var multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, string[]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, string[]] >"trimmer" : "trimmer" >["trimming", "edging"] : string[] @@ -31,12 +31,12 @@ let [, skillA = ["noSkill", "noSkill"]] = multiRobotA; >["noSkill", "noSkill"] : string[] >"noSkill" : "noSkill" >"noSkill" : "noSkill" ->multiRobotA : [string, string[]] +>multiRobotA : MultiSkilledRobot let [nameMB = "noName" ] = multiRobotB; >nameMB : string >"noName" : "noName" ->multiRobotB : [string, string[]] +>multiRobotB : MultiSkilledRobot let [nameMA = "noName", [primarySkillA = "noSkill", secondarySkillA = "noSkill"] = ["noSkill", "noSkill"]] = multiRobotA; >nameMA : string @@ -48,7 +48,7 @@ let [nameMA = "noName", [primarySkillA = "noSkill", secondarySkillA = "noSkill"] >["noSkill", "noSkill"] : [string, string] >"noSkill" : "noSkill" >"noSkill" : "noSkill" ->multiRobotA : [string, string[]] +>multiRobotA : MultiSkilledRobot let [nameMC = "noName" ] = ["roomba", ["vaccum", "mopping"]]; >nameMC : string diff --git a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.types b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.types index 2f9d1dac6e3b0..8968f49732e19 100644 --- a/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.types +++ b/tests/baselines/reference/sourceMapValidationDestructuringVariableStatementArrayBindingPatternDefaultValues3.types @@ -7,27 +7,27 @@ declare var console: { >msg : any } type Robot = [number, string, string]; ->Robot : [number, string, string] +>Robot : Robot type MultiSkilledRobot = [string, string[]]; ->MultiSkilledRobot : [string, string[]] +>MultiSkilledRobot : MultiSkilledRobot var robotA: Robot = [1, "mower", "mowing"]; ->robotA : [number, string, string] +>robotA : Robot >[1, "mower", "mowing"] : [number, string, string] >1 : 1 >"mower" : "mower" >"mowing" : "mowing" var robotB: Robot = [2, "trimmer", "trimming"]; ->robotB : [number, string, string] +>robotB : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" >"trimming" : "trimming" var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; ->multiRobotA : [string, string[]] +>multiRobotA : MultiSkilledRobot >["mower", ["mowing", ""]] : [string, string[]] >"mower" : "mower" >["mowing", ""] : string[] @@ -35,7 +35,7 @@ var multiRobotA: MultiSkilledRobot = ["mower", ["mowing", ""]]; >"" : "" var multiRobotB: MultiSkilledRobot = ["trimmer", ["trimming", "edging"]]; ->multiRobotB : [string, string[]] +>multiRobotB : MultiSkilledRobot >["trimmer", ["trimming", "edging"]] : [string, string[]] >"trimmer" : "trimmer" >["trimming", "edging"] : string[] @@ -61,23 +61,23 @@ let multiRobotAInfo: (string | string[])[]; >multiRobotAInfo : (string | string[])[] [, nameA = "helloNoName"] = robotA; ->[, nameA = "helloNoName"] = robotA : [number, string, string] +>[, nameA = "helloNoName"] = robotA : Robot >[, nameA = "helloNoName"] : [undefined, string] > : undefined >nameA = "helloNoName" : "helloNoName" >nameA : string >"helloNoName" : "helloNoName" ->robotA : [number, string, string] +>robotA : Robot [, nameB = "helloNoName"] = getRobotB(); ->[, nameB = "helloNoName"] = getRobotB() : [number, string, string] +>[, nameB = "helloNoName"] = getRobotB() : Robot >[, nameB = "helloNoName"] : [undefined, string] > : undefined >nameB = "helloNoName" : "helloNoName" >nameB : string >"helloNoName" : "helloNoName" ->getRobotB() : [number, string, string] ->getRobotB : () => [number, string, string] +>getRobotB() : Robot +>getRobotB : () => Robot [, nameB = "helloNoName"] = [2, "trimmer", "trimming"]; >[, nameB = "helloNoName"] = [2, "trimmer", "trimming"] : [number, string, string] @@ -92,23 +92,23 @@ let multiRobotAInfo: (string | string[])[]; >"trimming" : "trimming" [, multiSkillB = []] = multiRobotB; ->[, multiSkillB = []] = multiRobotB : [string, string[]] +>[, multiSkillB = []] = multiRobotB : MultiSkilledRobot >[, multiSkillB = []] : [undefined, undefined[]] > : undefined >multiSkillB = [] : undefined[] >multiSkillB : string[] >[] : undefined[] ->multiRobotB : [string, string[]] +>multiRobotB : MultiSkilledRobot [, multiSkillB = []] = getMultiRobotB(); ->[, multiSkillB = []] = getMultiRobotB() : [string, string[]] +>[, multiSkillB = []] = getMultiRobotB() : MultiSkilledRobot >[, multiSkillB = []] : [undefined, undefined[]] > : undefined >multiSkillB = [] : undefined[] >multiSkillB : string[] >[] : undefined[] ->getMultiRobotB() : [string, string[]] ->getMultiRobotB : () => [string, string[]] +>getMultiRobotB() : MultiSkilledRobot +>getMultiRobotB : () => MultiSkilledRobot [, multiSkillB = []] = ["roomba", ["vaccum", "mopping"]]; >[, multiSkillB = []] = ["roomba", ["vaccum", "mopping"]] : [string, string[]] @@ -124,23 +124,23 @@ let multiRobotAInfo: (string | string[])[]; >"mopping" : "mopping" [numberB = -1] = robotB; ->[numberB = -1] = robotB : [number, string, string] +>[numberB = -1] = robotB : Robot >[numberB = -1] : [number] >numberB = -1 : -1 >numberB : number >-1 : -1 >1 : 1 ->robotB : [number, string, string] +>robotB : Robot [numberB = -1] = getRobotB(); ->[numberB = -1] = getRobotB() : [number, string, string] +>[numberB = -1] = getRobotB() : Robot >[numberB = -1] : [number] >numberB = -1 : -1 >numberB : number >-1 : -1 >1 : 1 ->getRobotB() : [number, string, string] ->getRobotB : () => [number, string, string] +>getRobotB() : Robot +>getRobotB : () => Robot [numberB = -1] = [2, "trimmer", "trimming"]; >[numberB = -1] = [2, "trimmer", "trimming"] : [number, string, string] @@ -155,21 +155,21 @@ let multiRobotAInfo: (string | string[])[]; >"trimming" : "trimming" [nameMB = "helloNoName"] = multiRobotB; ->[nameMB = "helloNoName"] = multiRobotB : [string, string[]] +>[nameMB = "helloNoName"] = multiRobotB : MultiSkilledRobot >[nameMB = "helloNoName"] : [string] >nameMB = "helloNoName" : "helloNoName" >nameMB : string >"helloNoName" : "helloNoName" ->multiRobotB : [string, string[]] +>multiRobotB : MultiSkilledRobot [nameMB = "helloNoName"] = getMultiRobotB(); ->[nameMB = "helloNoName"] = getMultiRobotB() : [string, string[]] +>[nameMB = "helloNoName"] = getMultiRobotB() : MultiSkilledRobot >[nameMB = "helloNoName"] : [string] >nameMB = "helloNoName" : "helloNoName" >nameMB : string >"helloNoName" : "helloNoName" ->getMultiRobotB() : [string, string[]] ->getMultiRobotB : () => [string, string[]] +>getMultiRobotB() : MultiSkilledRobot +>getMultiRobotB : () => MultiSkilledRobot [nameMB = "helloNoName"] = ["trimmer", ["trimming", "edging"]]; >[nameMB = "helloNoName"] = ["trimmer", ["trimming", "edging"]] : [string, string[]] @@ -184,7 +184,7 @@ let multiRobotAInfo: (string | string[])[]; >"edging" : "edging" [numberB = -1, nameB = "helloNoName", skillB = "noSkill"] = robotB; ->[numberB = -1, nameB = "helloNoName", skillB = "noSkill"] = robotB : [number, string, string] +>[numberB = -1, nameB = "helloNoName", skillB = "noSkill"] = robotB : Robot >[numberB = -1, nameB = "helloNoName", skillB = "noSkill"] : [number, string, string] >numberB = -1 : -1 >numberB : number @@ -196,10 +196,10 @@ let multiRobotAInfo: (string | string[])[]; >skillB = "noSkill" : "noSkill" >skillB : string >"noSkill" : "noSkill" ->robotB : [number, string, string] +>robotB : Robot [numberB = -1, nameB = "helloNoName", skillB = "noSkill"] = getRobotB(); ->[numberB = -1, nameB = "helloNoName", skillB = "noSkill"] = getRobotB() : [number, string, string] +>[numberB = -1, nameB = "helloNoName", skillB = "noSkill"] = getRobotB() : Robot >[numberB = -1, nameB = "helloNoName", skillB = "noSkill"] : [number, string, string] >numberB = -1 : -1 >numberB : number @@ -211,8 +211,8 @@ let multiRobotAInfo: (string | string[])[]; >skillB = "noSkill" : "noSkill" >skillB : string >"noSkill" : "noSkill" ->getRobotB() : [number, string, string] ->getRobotB : () => [number, string, string] +>getRobotB() : Robot +>getRobotB : () => Robot [numberB = -1, nameB = "helloNoName", skillB = "noSkill"] = [2, "trimmer", "trimming"]; >[numberB = -1, nameB = "helloNoName", skillB = "noSkill"] = [2, "trimmer", "trimming"] : [number, string, string] @@ -233,7 +233,7 @@ let multiRobotAInfo: (string | string[])[]; >"trimming" : "trimming" [nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] = multiRobotB; ->[nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] = multiRobotB : [string, string[]] +>[nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] = multiRobotB : MultiSkilledRobot >[nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] : [string, []] >nameMB = "helloNoName" : "helloNoName" >nameMB : string @@ -247,10 +247,10 @@ let multiRobotAInfo: (string | string[])[]; >secondarySkillB : string >"noSkill" : "noSkill" >[] : [] ->multiRobotB : [string, string[]] +>multiRobotB : MultiSkilledRobot [nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] = getMultiRobotB(); ->[nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] = getMultiRobotB() : [string, string[]] +>[nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] = getMultiRobotB() : MultiSkilledRobot >[nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] : [string, []] >nameMB = "helloNoName" : "helloNoName" >nameMB : string @@ -264,8 +264,8 @@ let multiRobotAInfo: (string | string[])[]; >secondarySkillB : string >"noSkill" : "noSkill" >[] : [] ->getMultiRobotB() : [string, string[]] ->getMultiRobotB : () => [string, string[]] +>getMultiRobotB() : MultiSkilledRobot +>getMultiRobotB : () => MultiSkilledRobot [nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] = >[nameMB = "helloNoName", [primarySkillB = "noSkill", secondarySkillB = "noSkill"] = []] = ["trimmer", ["trimming", "edging"]] : [string, [string, string]] @@ -291,7 +291,7 @@ let multiRobotAInfo: (string | string[])[]; >"edging" : "edging" [numberB = -1, ...robotAInfo] = robotB; ->[numberB = -1, ...robotAInfo] = robotB : [number, string, string] +>[numberB = -1, ...robotAInfo] = robotB : Robot >[numberB = -1, ...robotAInfo] : [number, ...(string | number)[]] >numberB = -1 : -1 >numberB : number @@ -299,10 +299,10 @@ let multiRobotAInfo: (string | string[])[]; >1 : 1 >...robotAInfo : string | number >robotAInfo : (string | number)[] ->robotB : [number, string, string] +>robotB : Robot [numberB = -1, ...robotAInfo] = getRobotB(); ->[numberB = -1, ...robotAInfo] = getRobotB() : [number, string, string] +>[numberB = -1, ...robotAInfo] = getRobotB() : Robot >[numberB = -1, ...robotAInfo] : [number, ...(string | number)[]] >numberB = -1 : -1 >numberB : number @@ -310,11 +310,11 @@ let multiRobotAInfo: (string | string[])[]; >1 : 1 >...robotAInfo : string | number >robotAInfo : (string | number)[] ->getRobotB() : [number, string, string] ->getRobotB : () => [number, string, string] +>getRobotB() : Robot +>getRobotB : () => Robot [numberB = -1, ...robotAInfo] = [2, "trimmer", "trimming"]; ->[numberB = -1, ...robotAInfo] = [2, "trimmer", "trimming"] : [number, string, string] +>[numberB = -1, ...robotAInfo] = [2, "trimmer", "trimming"] : Robot >[numberB = -1, ...robotAInfo] : [number, ...(string | number)[]] >numberB = -1 : -1 >numberB : number @@ -322,7 +322,7 @@ let multiRobotAInfo: (string | string[])[]; >1 : 1 >...robotAInfo : string | number >robotAInfo : (string | number)[] ->[2, "trimmer", "trimming"] : [number, string, string] +>[2, "trimmer", "trimming"] : Robot >[2, "trimmer", "trimming"] : [number, string, string] >2 : 2 >"trimmer" : "trimmer" @@ -342,15 +342,15 @@ if (nameA == nameB) { } function getRobotB() { ->getRobotB : () => [number, string, string] +>getRobotB : () => Robot return robotB; ->robotB : [number, string, string] +>robotB : Robot } function getMultiRobotB() { ->getMultiRobotB : () => [string, string[]] +>getMultiRobotB : () => MultiSkilledRobot return multiRobotB; ->multiRobotB : [string, string[]] +>multiRobotB : MultiSkilledRobot } diff --git a/tests/baselines/reference/specedNoStackBlown.types b/tests/baselines/reference/specedNoStackBlown.types index 654f98941df1a..f2ef490fa8098 100644 --- a/tests/baselines/reference/specedNoStackBlown.types +++ b/tests/baselines/reference/specedNoStackBlown.types @@ -26,10 +26,10 @@ type ErrorMsg = >field : string export type Spec = [Predicate, ErrorMsg]; ->Spec : [Predicate, ErrorMsg] +>Spec : Spec export type SpecArray = Array>; ->SpecArray : [Predicate, ErrorMsg][] +>SpecArray : Spec[] export type SpecFunction = [INPUT] extends [ReadonlyArray] >SpecFunction : SpecFunction diff --git a/tests/baselines/reference/spreadBooleanRespectsFreshness.types b/tests/baselines/reference/spreadBooleanRespectsFreshness.types index c607422b0629a..cd20dc31944b6 100644 --- a/tests/baselines/reference/spreadBooleanRespectsFreshness.types +++ b/tests/baselines/reference/spreadBooleanRespectsFreshness.types @@ -7,7 +7,7 @@ type FooBase = string | false; >false : false type FooArray = FooBase[]; ->FooArray : FooBase[] +>FooArray : FooArray declare let foo1: Foo; >foo1 : Foo @@ -20,13 +20,13 @@ foo1 = [...Array.isArray(foo2) ? foo2 : [foo2]]; >foo1 : Foo >[...Array.isArray(foo2) ? foo2 : [foo2]] : FooBase[] >...Array.isArray(foo2) ? foo2 : [foo2] : FooBase ->Array.isArray(foo2) ? foo2 : [foo2] : FooBase[] +>Array.isArray(foo2) ? foo2 : [foo2] : FooArray >Array.isArray(foo2) : boolean >Array.isArray : (arg: any) => arg is any[] >Array : ArrayConstructor >isArray : (arg: any) => arg is any[] >foo2 : Foo ->foo2 : FooBase[] +>foo2 : FooArray >[foo2] : FooBase[] >foo2 : FooBase diff --git a/tests/baselines/reference/spreadTypeVariable.types b/tests/baselines/reference/spreadTypeVariable.types index c5de712fb19b7..0e836355d420e 100644 --- a/tests/baselines/reference/spreadTypeVariable.types +++ b/tests/baselines/reference/spreadTypeVariable.types @@ -37,7 +37,7 @@ function f4(arg: T) { } function f5(arg: T) { ->f5 : (arg: T) => T +>f5 : (arg: T) => T >key : string >arg : T diff --git a/tests/baselines/reference/tupleTypes.errors.txt b/tests/baselines/reference/tupleTypes.errors.txt index af76c872a6f38..a3c2fc00eb4a0 100644 --- a/tests/baselines/reference/tupleTypes.errors.txt +++ b/tests/baselines/reference/tupleTypes.errors.txt @@ -9,7 +9,7 @@ tests/cases/compiler/tupleTypes.ts(18,1): error TS2322: Type '[number, string, n Type '3' is not assignable to type '2'. tests/cases/compiler/tupleTypes.ts(35,14): error TS2493: Tuple type '[number, string]' of length '2' has no element at index '2'. tests/cases/compiler/tupleTypes.ts(36,5): error TS2403: Subsequent variable declarations must have the same type. Variable 'tt2' must be of type 'undefined', but here has type 'string | number'. -tests/cases/compiler/tupleTypes.ts(41,1): error TS2322: Type '[]' is not assignable to type '[number, string]'. +tests/cases/compiler/tupleTypes.ts(41,1): error TS2739: Type '[]' is missing the following properties from type '[number, string]': 0, 1 tests/cases/compiler/tupleTypes.ts(47,1): error TS2322: Type '[number, string]' is not assignable to type 'number[]'. Type 'string | number' is not assignable to type 'number'. Type 'string' is not assignable to type 'number'. @@ -87,7 +87,7 @@ tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is n tt = [undefined, undefined]; tt = []; // Error ~~ -!!! error TS2322: Type '[]' is not assignable to type '[number, string]'. +!!! error TS2739: Type '[]' is missing the following properties from type '[number, string]': 0, 1 var a: number[]; var a1: [number, string]; diff --git a/tests/baselines/reference/typeAliases.types b/tests/baselines/reference/typeAliases.types index 8790c043adffa..3eff23307dca0 100644 --- a/tests/baselines/reference/typeAliases.types +++ b/tests/baselines/reference/typeAliases.types @@ -183,22 +183,22 @@ f15(E.x).toLowerCase(); >toLowerCase : () => string type StringAndBoolean = [string, boolean] ->StringAndBoolean : [string, boolean] +>StringAndBoolean : StringAndBoolean declare function f16(s: StringAndBoolean): string; ->f16 : (s: [string, boolean]) => string ->s : [string, boolean] +>f16 : (s: StringAndBoolean) => string +>s : StringAndBoolean var x: [string, boolean]; >x : [string, boolean] f16(x); >f16(x) : string ->f16 : (s: [string, boolean]) => string +>f16 : (s: StringAndBoolean) => string >x : [string, boolean] var y: StringAndBoolean = ["1", false]; ->y : [string, boolean] +>y : StringAndBoolean >["1", false] : [string, false] >"1" : "1" >false : false @@ -207,7 +207,7 @@ y[0].toLowerCase(); >y[0].toLowerCase() : string >y[0].toLowerCase : () => string >y[0] : string ->y : [string, boolean] +>y : StringAndBoolean >0 : 0 >toLowerCase : () => string diff --git a/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty.types b/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty.types index 4e3d2e0743e9d..1f36901d43767 100644 --- a/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty.types +++ b/tests/baselines/reference/typeGuardNarrowsIndexedAccessOfKnownProperty.types @@ -208,10 +208,10 @@ interface Y { } type A = ["aa", number]; ->A : ["aa", number] +>A : A type B = ["bb", string]; ->B : ["bb", string] +>B : B type Z = X | Y; >Z : Z @@ -271,7 +271,7 @@ function check(z: Z, c: C) { var aa: number = c[1] // should be number >aa : number >c[1] : number ->c : ["aa", number] +>c : A >1 : 1 break; @@ -281,7 +281,7 @@ function check(z: Z, c: C) { var bb: string = c[1] // should be string >bb : string >c[1] : string ->c : ["bb", string] +>c : B >1 : 1 break; diff --git a/tests/baselines/reference/typeInferenceLiteralUnion.types b/tests/baselines/reference/typeInferenceLiteralUnion.types index de4637c52c5a5..84a65ccbc534b 100644 --- a/tests/baselines/reference/typeInferenceLiteralUnion.types +++ b/tests/baselines/reference/typeInferenceLiteralUnion.types @@ -56,11 +56,11 @@ export function extent(array: Array): [T | Pri let extentMixed: [Primitive | NumCoercible, Primitive | NumCoercible] | [undefined, undefined]; ->extentMixed : [undefined, undefined] | [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] +>extentMixed : [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] | [undefined, undefined] extentMixed = extent([new NumCoercible(10), 13, '12', true]); >extentMixed = extent([new NumCoercible(10), 13, '12', true]) : [undefined, undefined] | [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] ->extentMixed : [undefined, undefined] | [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] +>extentMixed : [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] | [undefined, undefined] >extent([new NumCoercible(10), 13, '12', true]) : [undefined, undefined] | [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] >extent : (array: (string | number | boolean | Date | T)[]) => [string | number | boolean | Date | T, string | number | boolean | Date | T] | [undefined, undefined] >[new NumCoercible(10), 13, '12', true] : (string | number | true | NumCoercible)[] diff --git a/tests/baselines/reference/typePredicateStructuralMatch.types b/tests/baselines/reference/typePredicateStructuralMatch.types index b4f5dbea3f155..48cca07cf10f3 100644 --- a/tests/baselines/reference/typePredicateStructuralMatch.types +++ b/tests/baselines/reference/typePredicateStructuralMatch.types @@ -2,25 +2,25 @@ // Repro from #12235 getResults1([]); ->getResults1([]) : Result[] ->getResults1 : (value: Result[] | { data: Result[]; }) => Result[] +>getResults1([]) : Results +>getResults1 : (value: Results | { data: Results; }) => Results >[] : undefined[] getResults1({data: []}); ->getResults1({data: []}) : Result[] ->getResults1 : (value: Result[] | { data: Result[]; }) => Result[] +>getResults1({data: []}) : Results +>getResults1 : (value: Results | { data: Results; }) => Results >{data: []} : { data: undefined[]; } >data : undefined[] >[] : undefined[] getResults2([]); ->getResults2([]) : Result[] ->getResults2 : (value: Result[] | { data: Result[]; }) => Result[] +>getResults2([]) : Results +>getResults2 : (value: Results | { data: Results; }) => Results >[] : undefined[] getResults2({data: []}); ->getResults2({data: []}) : Result[] ->getResults2 : (value: Result[] | { data: Result[]; }) => Result[] +>getResults2({data: []}) : Results +>getResults2 : (value: Results | { data: Results; }) => Results >{data: []} : { data: undefined[]; } >data : undefined[] >[] : undefined[] @@ -30,7 +30,7 @@ type Result = { value: string }; >value : string type Results = Result[]; ->Results : Result[] +>Results : Results function isResponseInData(value: T | { data: T}): value is { data: T } { >isResponseInData : (value: T | { data: T; }) => value is { data: T; } @@ -47,19 +47,19 @@ function isResponseInData(value: T | { data: T}): value is { data: T } { } function getResults1(value: Results | { data: Results }): Results { ->getResults1 : (value: Result[] | { data: Result[]; }) => Result[] ->value : Result[] | { data: Result[]; } ->data : Result[] +>getResults1 : (value: Results | { data: Results; }) => Results +>value : Results | { data: Results; } +>data : Results return isResponseInData(value) ? value.data : value; ->isResponseInData(value) ? value.data : value : Result[] +>isResponseInData(value) ? value.data : value : Results >isResponseInData(value) : boolean >isResponseInData : (value: T | { data: T; }) => value is { data: T; } ->value : Result[] | { data: Result[]; } ->value.data : Result[] ->value : { data: Result[]; } ->data : Result[] ->value : Result[] +>value : Results | { data: Results; } +>value.data : Results +>value : { data: Results; } +>data : Results +>value : Results } function isPlainResponse(value: T | { data: T}): value is T { @@ -77,17 +77,17 @@ function isPlainResponse(value: T | { data: T}): value is T { } function getResults2(value: Results | { data: Results }): Results { ->getResults2 : (value: Result[] | { data: Result[]; }) => Result[] ->value : Result[] | { data: Result[]; } ->data : Result[] +>getResults2 : (value: Results | { data: Results; }) => Results +>value : Results | { data: Results; } +>data : Results return isPlainResponse(value) ? value : value.data; ->isPlainResponse(value) ? value : value.data : Result[] +>isPlainResponse(value) ? value : value.data : Results >isPlainResponse(value) : boolean >isPlainResponse : (value: T | { data: T; }) => value is T ->value : Result[] | { data: Result[]; } ->value : Result[] ->value.data : Result[] ->value : { data: Result[]; } ->data : Result[] +>value : Results | { data: Results; } +>value : Results +>value.data : Results +>value : { data: Results; } +>data : Results } diff --git a/tests/baselines/reference/unionTypeWithLeadingOperator.types b/tests/baselines/reference/unionTypeWithLeadingOperator.types index 930ff71f3f74b..63d2e7c018d5f 100644 --- a/tests/baselines/reference/unionTypeWithLeadingOperator.types +++ b/tests/baselines/reference/unionTypeWithLeadingOperator.types @@ -12,7 +12,7 @@ type B = >type : "DECREMENT" type C = [| 0 | 1, | "foo" | "bar"]; ->C : [0 | 1, "foo" | "bar"] +>C : C export type D = >D : D diff --git a/tests/baselines/reference/unionsOfTupleTypes1.errors.txt b/tests/baselines/reference/unionsOfTupleTypes1.errors.txt index da997e988eef5..344bd49f54f35 100644 --- a/tests/baselines/reference/unionsOfTupleTypes1.errors.txt +++ b/tests/baselines/reference/unionsOfTupleTypes1.errors.txt @@ -1,10 +1,10 @@ -tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(8,15): error TS2493: Tuple type '[string, number]' of length '2' has no element at index '2'. +tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(8,15): error TS2493: Tuple type 'T1' of length '2' has no element at index '2'. tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(13,15): error TS2339: Property '2' does not exist on type 'T2'. -tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(27,20): error TS2493: Tuple type '[string, number]' of length '2' has no element at index '2'. +tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(27,20): error TS2493: Tuple type 'T1' of length '2' has no element at index '2'. tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(28,20): error TS2339: Property '2' does not exist on type 'T2'. -tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(31,16): error TS2493: Tuple type '[string, number]' of length '2' has no element at index '2'. +tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(31,16): error TS2493: Tuple type 'T1' of length '2' has no element at index '2'. tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(32,16): error TS2339: Property '2' does not exist on type 'T2'. -tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(37,18): error TS2493: Tuple type '[string, number]' of length '2' has no element at index '2'. +tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(37,18): error TS2493: Tuple type 'T1' of length '2' has no element at index '2'. tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(41,18): error TS2339: Property '2' does not exist on type 'T2'. @@ -18,7 +18,7 @@ tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(41,18): error TS2339: type T11 = T1[1]; // number type T12 = T1[2]; // undefined ~ -!!! error TS2493: Tuple type '[string, number]' of length '2' has no element at index '2'. +!!! error TS2493: Tuple type 'T1' of length '2' has no element at index '2'. type T1N = T1[number]; // string | number type T20 = T2[0]; // string | boolean @@ -41,7 +41,7 @@ tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(41,18): error TS2339: function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { let [d10, d11, d12] = t1; // string, number ~~~ -!!! error TS2493: Tuple type '[string, number]' of length '2' has no element at index '2'. +!!! error TS2493: Tuple type 'T1' of length '2' has no element at index '2'. let [d20, d21, d22] = t2; // string | boolean, number | undefined ~~~ !!! error TS2339: Property '2' does not exist on type 'T2'. @@ -49,7 +49,7 @@ tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(41,18): error TS2339: let [d40, d41, d42] = t4; // string | boolean, number | undefined, number | undefined [d10, d11, d12] = t1; ~~~ -!!! error TS2493: Tuple type '[string, number]' of length '2' has no element at index '2'. +!!! error TS2493: Tuple type 'T1' of length '2' has no element at index '2'. [d20, d21, d22] = t2; ~~~ !!! error TS2339: Property '2' does not exist on type 'T2'. @@ -59,7 +59,7 @@ tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts(41,18): error TS2339: let t11 = t1[1]; // number let t12 = t1[2]; // undefined ~ -!!! error TS2493: Tuple type '[string, number]' of length '2' has no element at index '2'. +!!! error TS2493: Tuple type 'T1' of length '2' has no element at index '2'. let t1x = t1[x]; // string | number let t20 = t2[0]; // string | boolean let t21 = t2[1]; // number | undefined diff --git a/tests/baselines/reference/unionsOfTupleTypes1.types b/tests/baselines/reference/unionsOfTupleTypes1.types index e0867cd104568..f1142821d2850 100644 --- a/tests/baselines/reference/unionsOfTupleTypes1.types +++ b/tests/baselines/reference/unionsOfTupleTypes1.types @@ -1,12 +1,12 @@ === tests/cases/conformance/types/tuple/unionsOfTupleTypes1.ts === type T1 = [string, number]; ->T1 : [string, number] +>T1 : T1 type T2 = [boolean] | [string, number]; >T2 : T2 type T3 = [string, ...number[]]; ->T3 : [string, ...number[]] +>T3 : T3 type T4 = [boolean] | [string, ...number[]]; >T4 : T4 @@ -60,10 +60,10 @@ type T4N = T4[number]; // string | number | boolean >T4N : string | number | boolean function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { ->f1 : (t1: [string, number], t2: T2, t3: [string, ...number[]], t4: T4, x: number) => void ->t1 : [string, number] +>f1 : (t1: T1, t2: T2, t3: T3, t4: T4, x: number) => void +>t1 : T1 >t2 : T2 ->t3 : [string, ...number[]] +>t3 : T3 >t4 : T4 >x : number @@ -71,7 +71,7 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { >d10 : string >d11 : number >d12 : undefined ->t1 : [string, number] +>t1 : T1 let [d20, d21, d22] = t2; // string | boolean, number | undefined >d20 : string | boolean @@ -83,7 +83,7 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { >d30 : string >d31 : number >d32 : number ->t3 : [string, ...number[]] +>t3 : T3 let [d40, d41, d42] = t4; // string | boolean, number | undefined, number | undefined >d40 : string | boolean @@ -92,12 +92,12 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { >t4 : T4 [d10, d11, d12] = t1; ->[d10, d11, d12] = t1 : [string, number] +>[d10, d11, d12] = t1 : T1 >[d10, d11, d12] : [string, number, undefined] >d10 : string >d11 : number >d12 : undefined ->t1 : [string, number] +>t1 : T1 [d20, d21, d22] = t2; >[d20, d21, d22] = t2 : T2 @@ -108,12 +108,12 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { >t2 : T2 [d30, d31, d32] = t3; ->[d30, d31, d32] = t3 : [string, ...number[]] +>[d30, d31, d32] = t3 : T3 >[d30, d31, d32] : [string, number, number] >d30 : string >d31 : number >d32 : number ->t3 : [string, ...number[]] +>t3 : T3 [d40, d41, d42] = t4; >[d40, d41, d42] = t4 : T4 @@ -126,25 +126,25 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { let t10 = t1[0]; // string >t10 : string >t1[0] : string ->t1 : [string, number] +>t1 : T1 >0 : 0 let t11 = t1[1]; // number >t11 : number >t1[1] : number ->t1 : [string, number] +>t1 : T1 >1 : 1 let t12 = t1[2]; // undefined >t12 : undefined >t1[2] : undefined ->t1 : [string, number] +>t1 : T1 >2 : 2 let t1x = t1[x]; // string | number >t1x : string | number >t1[x] : string | number ->t1 : [string, number] +>t1 : T1 >x : number let t20 = t2[0]; // string | boolean @@ -174,25 +174,25 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { let t30 = t3[0]; // string >t30 : string >t3[0] : string ->t3 : [string, ...number[]] +>t3 : T3 >0 : 0 let t31 = t3[1]; // number >t31 : number >t3[1] : number ->t3 : [string, ...number[]] +>t3 : T3 >1 : 1 let t32 = t3[2]; // number >t32 : number >t3[2] : number ->t3 : [string, ...number[]] +>t3 : T3 >2 : 2 let t3x = t3[x]; // string | number >t3x : string | number >t3[x] : string | number ->t3 : [string, ...number[]] +>t3 : T3 >x : number let t40 = t4[0]; // string | boolean @@ -222,7 +222,7 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { t1[1] = 42; >t1[1] = 42 : 42 >t1[1] : number ->t1 : [string, number] +>t1 : T1 >1 : 1 >42 : 42 @@ -236,7 +236,7 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4, x: number) { t3[1] = 42; >t3[1] = 42 : 42 >t3[1] : number ->t3 : [string, ...number[]] +>t3 : T3 >1 : 1 >42 : 42 From bf0debb883b2a07c39a43b6148a80f4d61234876 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 27 Aug 2019 07:16:51 -0400 Subject: [PATCH 07/25] Handle missing global array type --- src/compiler/checker.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e49e449226563..e403c2f964fe4 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9620,7 +9620,8 @@ namespace ts { const target = getArrayOrTupleTargetType(node); const aliasSymbol = getAliasSymbolForTypeNode(node); const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); - links.resolvedType = node.kind === SyntaxKind.TupleType && node.elementTypes.length === 0 ? target : + links.resolvedType = target === emptyGenericType ? emptyObjectType : + node.kind === SyntaxKind.TupleType && node.elementTypes.length === 0 ? target : createDeferredTypeReference(target, node, /*mapper*/ undefined, aliasSymbol, aliasTypeArguments); } return links.resolvedType; From b18c70f8c0a15328b292e4e7fe11afb14ea50f6c Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 27 Aug 2019 07:23:52 -0400 Subject: [PATCH 08/25] Fix fourslash test --- .../codeFixClassImplementInterfaceMemberTypeAlias.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/cases/fourslash/codeFixClassImplementInterfaceMemberTypeAlias.ts b/tests/cases/fourslash/codeFixClassImplementInterfaceMemberTypeAlias.ts index 6fd8900d51bd3..8893d35b54909 100644 --- a/tests/cases/fourslash/codeFixClassImplementInterfaceMemberTypeAlias.ts +++ b/tests/cases/fourslash/codeFixClassImplementInterfaceMemberTypeAlias.ts @@ -10,8 +10,8 @@ verify.codeFix({ `type MyType = [string, number]; interface I { x: MyType; test(a: MyType): void; } class C implements I { - x: [string, number]; - test(a: [string, number]): void { + x: MyType; + test(a: MyType): void { throw new Error("Method not implemented."); } }`, From c2d0aa8931a44e19f294db71facb710a84abd047 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 27 Aug 2019 16:18:20 -0400 Subject: [PATCH 09/25] Only defer aliased array and tuple types --- src/compiler/checker.ts | 35 ++++++++++++++++++++++++++++++----- 1 file changed, 30 insertions(+), 5 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e403c2f964fe4..1231d4b31f1fe 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9614,15 +9614,40 @@ namespace ts { return getTupleTypeOfArity(node.elementTypes.length, minLength, !!restElement, readonly, /*associatedNames*/ undefined); } + function isAliasedType(node: Node): boolean { + const parent = node.parent; + switch (parent.kind) { + case SyntaxKind.ParenthesizedType: + case SyntaxKind.ArrayType: + case SyntaxKind.TupleType: + case SyntaxKind.RestType: + case SyntaxKind.UnionType: + case SyntaxKind.IntersectionType: + case SyntaxKind.IndexedAccessType: + return isAliasedType(parent); + case SyntaxKind.TypeAliasDeclaration: + return true; + } + return false; + } + function getTypeFromArrayOrTupleTypeNode(node: ArrayTypeNode | TupleTypeNode): Type { const links = getNodeLinks(node); if (!links.resolvedType) { const target = getArrayOrTupleTargetType(node); - const aliasSymbol = getAliasSymbolForTypeNode(node); - const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); - links.resolvedType = target === emptyGenericType ? emptyObjectType : - node.kind === SyntaxKind.TupleType && node.elementTypes.length === 0 ? target : - createDeferredTypeReference(target, node, /*mapper*/ undefined, aliasSymbol, aliasTypeArguments); + if (target === emptyGenericType) { + links.resolvedType = emptyObjectType; + } + else if (isAliasedType(node)) { + const aliasSymbol = getAliasSymbolForTypeNode(node); + const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + links.resolvedType = node.kind === SyntaxKind.TupleType && node.elementTypes.length === 0 ? target : + createDeferredTypeReference(target, node, /*mapper*/ undefined, aliasSymbol, aliasTypeArguments); + } + else { + const elementTypes = node.kind === SyntaxKind.ArrayType ? [getTypeFromTypeNode(node.elementType)] : map(node.elementTypes, getTypeFromTypeNode); + links.resolvedType = createTypeReference(target, elementTypes); + } } return links.resolvedType; } From 8f3a91724e77f87e00923d2f505f004cc1d8e468 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 27 Aug 2019 16:29:50 -0400 Subject: [PATCH 10/25] Accept new baselines --- .../baselines/reference/arrayFrom.errors.txt | 2 -- .../reference/castingTuple.errors.txt | 2 -- .../reference/checkJsxChildrenProperty3.types | 4 ++-- .../checkJsxChildrenProperty4.errors.txt | 16 +++++++-------- .../reference/checkJsxChildrenProperty4.types | 4 ++-- .../complexRecursiveCollections.types | 16 +++++++-------- .../contextualSignatureInstantiation.types | 2 +- ...ectDependenceBetweenTypeAliases.errors.txt | 20 ++++++++++++++++++- .../directDependenceBetweenTypeAliases.types | 16 +++++++-------- .../recursiveResolveTypeMembers.errors.txt | 4 ++-- .../recursiveTypesWithTypeof.errors.txt | 7 +++---- .../reference/recursiveTypesWithTypeof.types | 6 +++--- .../reference/spreadTypeVariable.types | 2 +- .../baselines/reference/tupleTypes.errors.txt | 4 ++-- .../reference/typeInferenceLiteralUnion.types | 4 ++-- 15 files changed, 61 insertions(+), 48 deletions(-) diff --git a/tests/baselines/reference/arrayFrom.errors.txt b/tests/baselines/reference/arrayFrom.errors.txt index 7d9645f94208c..615bd1bf76955 100644 --- a/tests/baselines/reference/arrayFrom.errors.txt +++ b/tests/baselines/reference/arrayFrom.errors.txt @@ -1,7 +1,6 @@ tests/cases/compiler/arrayFrom.ts(20,7): error TS2322: Type 'A[]' is not assignable to type 'B[]'. Property 'b' is missing in type 'A' but required in type 'B'. tests/cases/compiler/arrayFrom.ts(23,7): error TS2322: Type 'A[]' is not assignable to type 'B[]'. - Type 'A' is not assignable to type 'B'. ==== tests/cases/compiler/arrayFrom.ts (2 errors) ==== @@ -34,7 +33,6 @@ tests/cases/compiler/arrayFrom.ts(23,7): error TS2322: Type 'A[]' is not assigna const result6: B[] = Array.from(inputALike); // expect error ~~~~~~~ !!! error TS2322: Type 'A[]' is not assignable to type 'B[]'. -!!! error TS2322: Type 'A' is not assignable to type 'B'. const result7: B[] = Array.from(inputALike, ({ a }): B => ({ b: a })); const result8: A[] = Array.from(inputARand); const result9: B[] = Array.from(inputARand, ({ a }): B => ({ b: a })); diff --git a/tests/baselines/reference/castingTuple.errors.txt b/tests/baselines/reference/castingTuple.errors.txt index 56941dfddd0a6..0a1d592e8b1cf 100644 --- a/tests/baselines/reference/castingTuple.errors.txt +++ b/tests/baselines/reference/castingTuple.errors.txt @@ -4,7 +4,6 @@ tests/cases/conformance/types/tuple/castingTuple.ts(14,15): error TS2352: Conver Types of property 'length' are incompatible. Type '3' is not comparable to type '2'. tests/cases/conformance/types/tuple/castingTuple.ts(15,14): error TS2352: Conversion of type '[number, string]' to type '[number, string, boolean]' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. - Property '2' is missing in type '[number, string]' but required in type '[number, string, boolean]'. tests/cases/conformance/types/tuple/castingTuple.ts(18,21): error TS2352: Conversion of type '[C, D]' to type '[C, D, A]' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. Property '2' is missing in type '[C, D]' but required in type '[C, D, A]'. tests/cases/conformance/types/tuple/castingTuple.ts(20,33): error TS2493: Tuple type '[C, D, A]' of length '3' has no element at index '5'. @@ -41,7 +40,6 @@ tests/cases/conformance/types/tuple/castingTuple.ts(33,1): error TS2304: Cannot var longer = numStrTuple as [number, string, boolean] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !!! error TS2352: Conversion of type '[number, string]' to type '[number, string, boolean]' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. -!!! error TS2352: Property '2' is missing in type '[number, string]' but required in type '[number, string, boolean]'. var classCDTuple: [C, D] = [new C(), new D()]; var interfaceIITuple = <[I, I]>classCDTuple; var classCDATuple = <[C, D, A]>classCDTuple; diff --git a/tests/baselines/reference/checkJsxChildrenProperty3.types b/tests/baselines/reference/checkJsxChildrenProperty3.types index 2d4380a197531..f2ed3dc8fd00a 100644 --- a/tests/baselines/reference/checkJsxChildrenProperty3.types +++ b/tests/baselines/reference/checkJsxChildrenProperty3.types @@ -31,11 +31,11 @@ class FetchUser extends React.Component { ? this.props.children(this.state.result) >this.props.children(this.state.result) : JSX.Element ->this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement | any[])[]) +>this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) >this.props : IFetchUserProps & { children?: React.ReactNode; } >this : this >props : IFetchUserProps & { children?: React.ReactNode; } ->children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement | any[])[]) +>children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) >this.state.result : any >this.state : any >this : this diff --git a/tests/baselines/reference/checkJsxChildrenProperty4.errors.txt b/tests/baselines/reference/checkJsxChildrenProperty4.errors.txt index 40eb1d77677f5..34bd218996483 100644 --- a/tests/baselines/reference/checkJsxChildrenProperty4.errors.txt +++ b/tests/baselines/reference/checkJsxChildrenProperty4.errors.txt @@ -1,8 +1,8 @@ tests/cases/conformance/jsx/file.tsx(24,28): error TS2551: Property 'NAme' does not exist on type 'IUser'. Did you mean 'Name'? -tests/cases/conformance/jsx/file.tsx(36,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement | any[]'. - Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more. -tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement | any[]'. - Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more. +tests/cases/conformance/jsx/file.tsx(36,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement'. + Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement': type, props +tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement'. + Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement': type, props ==== tests/cases/conformance/jsx/file.tsx (3 errors) ==== @@ -50,8 +50,8 @@ tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) = ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ) } ~~~~~~~~~~~~~ -!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement | any[]'. -!!! error TS2322: Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more. +!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement'. +!!! error TS2322: Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement': type, props !!! related TS6212 tests/cases/conformance/jsx/file.tsx:36:15: Did you mean to call this expression? { user => ( ~~~~~~~~~ @@ -59,8 +59,8 @@ tests/cases/conformance/jsx/file.tsx(39,15): error TS2322: Type '(user: IUser) = ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ) } ~~~~~~~~~~~~~ -!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | ReactElement | any[]'. -!!! error TS2322: Type '(user: IUser) => Element' is missing the following properties from type 'any[]': push, pop, concat, join, and 15 more. +!!! error TS2322: Type '(user: IUser) => Element' is not assignable to type 'string | number | boolean | any[] | ReactElement'. +!!! error TS2322: Type '(user: IUser) => Element' is missing the following properties from type 'ReactElement': type, props !!! related TS6212 tests/cases/conformance/jsx/file.tsx:39:15: Did you mean to call this expression? ); diff --git a/tests/baselines/reference/checkJsxChildrenProperty4.types b/tests/baselines/reference/checkJsxChildrenProperty4.types index 4f753cf9f3b03..067e8f2611af6 100644 --- a/tests/baselines/reference/checkJsxChildrenProperty4.types +++ b/tests/baselines/reference/checkJsxChildrenProperty4.types @@ -31,11 +31,11 @@ class FetchUser extends React.Component { ? this.props.children(this.state.result) >this.props.children(this.state.result) : JSX.Element ->this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement | any[])[]) +>this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) >this.props : IFetchUserProps & { children?: React.ReactNode; } >this : this >props : IFetchUserProps & { children?: React.ReactNode; } ->children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | React.ReactElement | any[])[]) +>children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) >this.state.result : any >this.state : any >this : this diff --git a/tests/baselines/reference/complexRecursiveCollections.types b/tests/baselines/reference/complexRecursiveCollections.types index 2450407e90d3c..feaff62048628 100644 --- a/tests/baselines/reference/complexRecursiveCollections.types +++ b/tests/baselines/reference/complexRecursiveCollections.types @@ -1029,28 +1029,28 @@ declare module Immutable { >value : T[K] merge(...collections: Array | Iterable<[string, any]>>): this; ->merge : (...collections: (Partial | Iterable<[string, any]>)[]) => this ->collections : (Partial | Iterable<[string, any]>)[] +>merge : (...collections: (Iterable<[string, any]> | Partial)[]) => this +>collections : (Iterable<[string, any]> | Partial)[] mergeDeep(...collections: Array | Iterable<[string, any]>>): this; ->mergeDeep : (...collections: (Partial | Iterable<[string, any]>)[]) => this ->collections : (Partial | Iterable<[string, any]>)[] +>mergeDeep : (...collections: (Iterable<[string, any]> | Partial)[]) => this +>collections : (Iterable<[string, any]> | Partial)[] mergeWith(merger: (oldVal: any, newVal: any, key: keyof T) => any, ...collections: Array | Iterable<[string, any]>>): this; ->mergeWith : (merger: (oldVal: any, newVal: any, key: keyof T) => any, ...collections: (Partial | Iterable<[string, any]>)[]) => this +>mergeWith : (merger: (oldVal: any, newVal: any, key: keyof T) => any, ...collections: (Iterable<[string, any]> | Partial)[]) => this >merger : (oldVal: any, newVal: any, key: keyof T) => any >oldVal : any >newVal : any >key : keyof T ->collections : (Partial | Iterable<[string, any]>)[] +>collections : (Iterable<[string, any]> | Partial)[] mergeDeepWith(merger: (oldVal: any, newVal: any, key: any) => any, ...collections: Array | Iterable<[string, any]>>): this; ->mergeDeepWith : (merger: (oldVal: any, newVal: any, key: any) => any, ...collections: (Partial | Iterable<[string, any]>)[]) => this +>mergeDeepWith : (merger: (oldVal: any, newVal: any, key: any) => any, ...collections: (Iterable<[string, any]> | Partial)[]) => this >merger : (oldVal: any, newVal: any, key: any) => any >oldVal : any >newVal : any >key : any ->collections : (Partial | Iterable<[string, any]>)[] +>collections : (Iterable<[string, any]> | Partial)[] delete(key: K): this; >delete : (key: K) => this diff --git a/tests/baselines/reference/contextualSignatureInstantiation.types b/tests/baselines/reference/contextualSignatureInstantiation.types index 57e8f79a28f39..ae5a40005377e 100644 --- a/tests/baselines/reference/contextualSignatureInstantiation.types +++ b/tests/baselines/reference/contextualSignatureInstantiation.types @@ -108,7 +108,7 @@ var d = bar(1, "one", h); // Should be number[] | string[] var d = bar("one", 1, h); // Should be number[] | string[] >d : number[] | string[] ->bar("one", 1, h) : string[] | number[] +>bar("one", 1, h) : number[] | string[] >bar : (x: T, y: U, cb: (x: T, y: U) => V) => V >"one" : "one" >1 : 1 diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt index d396026717744..15e654df9a7f2 100644 --- a/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt @@ -4,9 +4,15 @@ tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts( tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(7,6): error TS2456: Type alias 'T0_3' circularly references itself. tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(11,6): error TS2456: Type alias 'T1' circularly references itself. tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(14,6): error TS2456: Type alias 'T2' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(25,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(26,6): error TS2456: Type alias 'T5' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(29,6): error TS2456: Type alias 'T6' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(30,6): error TS2456: Type alias 'T7' circularly references itself. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(31,5): error TS2502: 'yy' is referenced directly or indirectly in its own type annotation. +tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(32,6): error TS2456: Type alias 'T8' circularly references itself. -==== tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts (6 errors) ==== +==== tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts (12 errors) ==== // It is an error for the type specified in a type alias to depend on that type alias // A type alias directly depends on the type it aliases. @@ -44,13 +50,25 @@ tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts( // A type query directly depends on the type of the referenced entity. var x: T5[] = [] + ~ +!!! error TS2502: 'x' is referenced directly or indirectly in its own type annotation. type T5 = typeof x + ~~ +!!! error TS2456: Type alias 'T5' circularly references itself. class C1 {} type T6 = T7 | number + ~~ +!!! error TS2456: Type alias 'T6' circularly references itself. type T7 = typeof yy + ~~ +!!! error TS2456: Type alias 'T7' circularly references itself. var yy: [string, T8[]]; + ~~ +!!! error TS2502: 'yy' is referenced directly or indirectly in its own type annotation. type T8 = C + ~~ +!!! error TS2456: Type alias 'T8' circularly references itself. // legal cases type T9 = () => T9 diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.types b/tests/baselines/reference/directDependenceBetweenTypeAliases.types index 431b65eea8ccf..1ddbeb019cfc3 100644 --- a/tests/baselines/reference/directDependenceBetweenTypeAliases.types +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.types @@ -39,28 +39,28 @@ type T4 = [number, T4] // A type query directly depends on the type of the referenced entity. var x: T5[] = [] ->x : any[][][][][][][][][][][] +>x : any >[] : undefined[] type T5 = typeof x ->T5 : any[][][][][][][][][][][] ->x : any[][][][][][][][][][][] +>T5 : any +>x : any class C1 {} >C1 : C1 type T6 = T7 | number ->T6 : T6 +>T6 : any type T7 = typeof yy ->T7 : [string, C[]] ->yy : [string, C[]] +>T7 : any +>yy : any var yy: [string, T8[]]; ->yy : [string, C[]] +>yy : any type T8 = C ->T8 : C +>T8 : any // legal cases type T9 = () => T9 diff --git a/tests/baselines/reference/recursiveResolveTypeMembers.errors.txt b/tests/baselines/reference/recursiveResolveTypeMembers.errors.txt index 7bb5c5549841d..ad5fe6dc1aedc 100644 --- a/tests/baselines/reference/recursiveResolveTypeMembers.errors.txt +++ b/tests/baselines/reference/recursiveResolveTypeMembers.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/recursiveResolveTypeMembers.ts(4,49): error TS2589: Type instantiation is excessively deep and possibly infinite. +tests/cases/compiler/recursiveResolveTypeMembers.ts(4,49): error TS2577: Return type annotation circularly references itself. tests/cases/compiler/recursiveResolveTypeMembers.ts(4,58): error TS2304: Cannot find name 'H'. tests/cases/compiler/recursiveResolveTypeMembers.ts(4,62): error TS2574: A rest element type must be an array type. tests/cases/compiler/recursiveResolveTypeMembers.ts(4,79): error TS2304: Cannot find name 'R'. @@ -10,7 +10,7 @@ tests/cases/compiler/recursiveResolveTypeMembers.ts(4,79): error TS2304: Cannot type PromisedTuple void> = U extends (h: infer H, ...args: infer R) => [Promise, ...PromisedTuple] ? [] : [] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2589: Type instantiation is excessively deep and possibly infinite. +!!! error TS2577: Return type annotation circularly references itself. ~ !!! error TS2304: Cannot find name 'H'. ~~~~~~~~~~~~~~~~~~~ diff --git a/tests/baselines/reference/recursiveTypesWithTypeof.errors.txt b/tests/baselines/reference/recursiveTypesWithTypeof.errors.txt index 2807613c3d985..0604e38bd94d9 100644 --- a/tests/baselines/reference/recursiveTypesWithTypeof.errors.txt +++ b/tests/baselines/reference/recursiveTypesWithTypeof.errors.txt @@ -3,7 +3,7 @@ tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithType tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(6,5): error TS2502: 'e' is referenced directly or indirectly in its own type annotation. tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(10,5): error TS2502: 'f' is referenced directly or indirectly in its own type annotation. tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(12,5): error TS2502: 'f2' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(15,5): error TS2403: Subsequent variable declarations must have the same type. Variable 'f3' must be of type 'Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[]', but here has type 'any'. +tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(14,5): error TS2502: 'f3' is referenced directly or indirectly in its own type annotation. tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts(51,5): error TS2502: 'hy3' is referenced directly or indirectly in its own type annotation. @@ -32,10 +32,9 @@ tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithType !!! error TS2502: 'f2' is referenced directly or indirectly in its own type annotation. var f2: any; var f3: Foo[]; - var f3: any; ~~ -!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'f3' must be of type 'Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[]', but here has type 'any'. -!!! related TS6203 tests/cases/conformance/types/specifyingTypes/typeQueries/recursiveTypesWithTypeof.ts:14:5: 'f3' was also declared here. +!!! error TS2502: 'f3' is referenced directly or indirectly in its own type annotation. + var f3: any; // None of these declarations should have any errors! // Truly recursive types diff --git a/tests/baselines/reference/recursiveTypesWithTypeof.types b/tests/baselines/reference/recursiveTypesWithTypeof.types index 1a527bfa470b1..5625e7919cd2a 100644 --- a/tests/baselines/reference/recursiveTypesWithTypeof.types +++ b/tests/baselines/reference/recursiveTypesWithTypeof.types @@ -37,11 +37,11 @@ var f2: any; >f2 : any var f3: Foo[]; ->f3 : Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[] ->f3 : Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[] +>f3 : any +>f3 : any var f3: any; ->f3 : Foo[]>[]>[]>[]>[]>[]>[]>[]>[]>[]>[] +>f3 : any // None of these declarations should have any errors! // Truly recursive types diff --git a/tests/baselines/reference/spreadTypeVariable.types b/tests/baselines/reference/spreadTypeVariable.types index 0e836355d420e..c5de712fb19b7 100644 --- a/tests/baselines/reference/spreadTypeVariable.types +++ b/tests/baselines/reference/spreadTypeVariable.types @@ -37,7 +37,7 @@ function f4(arg: T) { } function f5(arg: T) { ->f5 : (arg: T) => T +>f5 : (arg: T) => T >key : string >arg : T diff --git a/tests/baselines/reference/tupleTypes.errors.txt b/tests/baselines/reference/tupleTypes.errors.txt index a3c2fc00eb4a0..af76c872a6f38 100644 --- a/tests/baselines/reference/tupleTypes.errors.txt +++ b/tests/baselines/reference/tupleTypes.errors.txt @@ -9,7 +9,7 @@ tests/cases/compiler/tupleTypes.ts(18,1): error TS2322: Type '[number, string, n Type '3' is not assignable to type '2'. tests/cases/compiler/tupleTypes.ts(35,14): error TS2493: Tuple type '[number, string]' of length '2' has no element at index '2'. tests/cases/compiler/tupleTypes.ts(36,5): error TS2403: Subsequent variable declarations must have the same type. Variable 'tt2' must be of type 'undefined', but here has type 'string | number'. -tests/cases/compiler/tupleTypes.ts(41,1): error TS2739: Type '[]' is missing the following properties from type '[number, string]': 0, 1 +tests/cases/compiler/tupleTypes.ts(41,1): error TS2322: Type '[]' is not assignable to type '[number, string]'. tests/cases/compiler/tupleTypes.ts(47,1): error TS2322: Type '[number, string]' is not assignable to type 'number[]'. Type 'string | number' is not assignable to type 'number'. Type 'string' is not assignable to type 'number'. @@ -87,7 +87,7 @@ tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is n tt = [undefined, undefined]; tt = []; // Error ~~ -!!! error TS2739: Type '[]' is missing the following properties from type '[number, string]': 0, 1 +!!! error TS2322: Type '[]' is not assignable to type '[number, string]'. var a: number[]; var a1: [number, string]; diff --git a/tests/baselines/reference/typeInferenceLiteralUnion.types b/tests/baselines/reference/typeInferenceLiteralUnion.types index 84a65ccbc534b..de4637c52c5a5 100644 --- a/tests/baselines/reference/typeInferenceLiteralUnion.types +++ b/tests/baselines/reference/typeInferenceLiteralUnion.types @@ -56,11 +56,11 @@ export function extent(array: Array): [T | Pri let extentMixed: [Primitive | NumCoercible, Primitive | NumCoercible] | [undefined, undefined]; ->extentMixed : [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] | [undefined, undefined] +>extentMixed : [undefined, undefined] | [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] extentMixed = extent([new NumCoercible(10), 13, '12', true]); >extentMixed = extent([new NumCoercible(10), 13, '12', true]) : [undefined, undefined] | [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] ->extentMixed : [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] | [undefined, undefined] +>extentMixed : [undefined, undefined] | [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] >extent([new NumCoercible(10), 13, '12', true]) : [undefined, undefined] | [string | number | boolean | Date | NumCoercible, string | number | boolean | Date | NumCoercible] >extent : (array: (string | number | boolean | Date | T)[]) => [string | number | boolean | Date | T, string | number | boolean | Date | T] | [undefined, undefined] >[new NumCoercible(10), 13, '12', true] : (string | number | true | NumCoercible)[] From 842c588f3ef5b56bde3f71265d7bc7c243c539f6 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 28 Aug 2019 07:52:42 -0400 Subject: [PATCH 11/25] Exclude method symbols when relating tuple types --- src/compiler/checker.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 1231d4b31f1fe..529a357e34d3c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -14123,9 +14123,11 @@ namespace ts { // We only call this for union target types when we're attempting to do excess property checking - in those cases, we want to get _all possible props_ // from the target union, across all members const properties = target.flags & TypeFlags.Union ? getPossiblePropertiesOfUnionType(target as UnionType) : getPropertiesOfType(target); + const numericNamesOnly = isTupleType(source) && isTupleType(target); for (const targetProp of excludeProperties(properties, excludedProperties)) { - if (!(targetProp.flags & SymbolFlags.Prototype)) { - const sourceProp = getPropertyOfType(source, targetProp.escapedName); + const name = targetProp.escapedName; + if (!(targetProp.flags & SymbolFlags.Prototype) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length")) { + const sourceProp = getPropertyOfType(source, name); if (sourceProp && sourceProp !== targetProp) { const related = propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSymbol, reportErrors, isIntersectionConstituent); if (!related) { From fd8f9904490ec7cf93e1010604e7a4bec2a56756 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 29 Aug 2019 07:17:45 -0700 Subject: [PATCH 12/25] Fix instantiation of alias type arguments for deferred type references --- src/compiler/checker.ts | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 529a357e34d3c..85c3c10f15013 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -9115,13 +9115,15 @@ namespace ts { return type; } - function createDeferredTypeReference(target: GenericType, node: ArrayTypeNode | TupleTypeNode, mapper?: TypeMapper, aliasSymbol?: Symbol, aliasTypeArguments?: ReadonlyArray): DeferredTypeReference { + function createDeferredTypeReference(target: GenericType, node: ArrayTypeNode | TupleTypeNode, mapper?: TypeMapper): DeferredTypeReference { + const aliasSymbol = getAliasSymbolForTypeNode(node); + const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); const type = createObjectType(ObjectFlags.Reference, target.symbol); type.target = target; type.node = node; type.mapper = mapper; type.aliasSymbol = aliasSymbol; - type.aliasTypeArguments = aliasTypeArguments; + type.aliasTypeArguments = mapper ? instantiateTypes(aliasTypeArguments, mapper) : aliasTypeArguments; return type; } @@ -9639,10 +9641,8 @@ namespace ts { links.resolvedType = emptyObjectType; } else if (isAliasedType(node)) { - const aliasSymbol = getAliasSymbolForTypeNode(node); - const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); links.resolvedType = node.kind === SyntaxKind.TupleType && node.elementTypes.length === 0 ? target : - createDeferredTypeReference(target, node, /*mapper*/ undefined, aliasSymbol, aliasTypeArguments); + createDeferredTypeReference(target, node, /*mapper*/ undefined); } else { const elementTypes = node.kind === SyntaxKind.ArrayType ? [getTypeFromTypeNode(node.elementType)] : map(node.elementTypes, getTypeFromTypeNode); @@ -11504,7 +11504,7 @@ namespace ts { let result = links.instantiations!.get(id); if (!result) { const newMapper = createTypeMapper(typeParameters, typeArguments); - result = target.objectFlags & ObjectFlags.Reference ? instantiateDeferredTypeReference(type, newMapper) : + result = target.objectFlags & ObjectFlags.Reference ? createDeferredTypeReference((type).target, (type).node, newMapper) : target.objectFlags & ObjectFlags.Mapped ? instantiateMappedType(target, newMapper) : instantiateAnonymousType(target, newMapper); links.instantiations!.set(id, result); @@ -11638,10 +11638,6 @@ namespace ts { return result; } - function instantiateDeferredTypeReference(type: DeferredTypeReference, mapper: TypeMapper): TypeReference { - return createDeferredTypeReference(type.target, type.node, mapper, type.aliasSymbol, instantiateTypes(type.aliasTypeArguments, mapper)); - } - function getConditionalTypeInstantiation(type: ConditionalType, mapper: TypeMapper): Type { const root = type.root; if (root.outerTypeParameters) { From 6270ccc4b064cb9b66316d22d11a276c327bf886 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 29 Aug 2019 07:31:34 -0700 Subject: [PATCH 13/25] Accept new baselines --- .../reference/contextualTypingOfOptionalMembers.types | 8 ++++---- tests/baselines/reference/inferTypes1.types | 6 +++--- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/tests/baselines/reference/contextualTypingOfOptionalMembers.types b/tests/baselines/reference/contextualTypingOfOptionalMembers.types index 9df692608c2cd..8978cb86e078e 100644 --- a/tests/baselines/reference/contextualTypingOfOptionalMembers.types +++ b/tests/baselines/reference/contextualTypingOfOptionalMembers.types @@ -134,7 +134,7 @@ declare function app3>(obj: Optionsapp3({ state: 100, actions: [ s => s // Should be typed number => number ], view: (s, a) => undefined as any,}) : void >app3 : >(obj: Options) => void ->{ state: 100, actions: [ s => s // Should be typed number => number ], view: (s, a) => undefined as any,} : { state: number; actions: ((s: number) => number)[]; view: (s: number, a: ActionsArray) => any; } +>{ state: 100, actions: [ s => s // Should be typed number => number ], view: (s, a) => undefined as any,} : { state: number; actions: ((s: number) => number)[]; view: (s: number, a: ActionsArray) => any; } state: 100, >state : number @@ -151,10 +151,10 @@ app3({ ], view: (s, a) => undefined as any, ->view : (s: number, a: ActionsArray) => any ->(s, a) => undefined as any : (s: number, a: ActionsArray) => any +>view : (s: number, a: ActionsArray) => any +>(s, a) => undefined as any : (s: number, a: ActionsArray) => any >s : number ->a : ActionsArray +>a : ActionsArray >undefined as any : any >undefined : undefined diff --git a/tests/baselines/reference/inferTypes1.types b/tests/baselines/reference/inferTypes1.types index 02fa41fe4c8bf..f31c230620bf4 100644 --- a/tests/baselines/reference/inferTypes1.types +++ b/tests/baselines/reference/inferTypes1.types @@ -275,13 +275,13 @@ type Bar = T extends Foo ? Foo : never; >Bar : Bar type T90 = Bar<[string, string]>; // [string, string] ->T90 : Foo +>T90 : Foo type T91 = Bar<[string, "a"]>; // [string, "a"] ->T91 : Foo +>T91 : Foo type T92 = Bar<[string, "a"] & { x: string }>; // [string, "a"] ->T92 : Foo +>T92 : Foo >x : string type T93 = Bar<["a", string]>; // never From 2f0ac25a00e890004354b095f8bf5b1267222193 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 30 Aug 2019 07:57:55 -0700 Subject: [PATCH 14/25] Defer resolution of type arguments in aliased type references --- src/compiler/checker.ts | 46 ++++++++++++++++++++--------------------- src/compiler/types.ts | 6 +++--- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 85c3c10f15013..17023d6e5b6dd 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6382,7 +6382,6 @@ namespace ts { return type.resolvedBaseTypes = emptyArray; } const baseTypeNode = getBaseTypeNodeOfClass(type)!; - const typeArgs = typeArgumentsFromTypeReferenceNode(baseTypeNode); let baseType: Type; const originalBaseType = baseConstructorType.symbol ? getDeclaredTypeOfSymbol(baseConstructorType.symbol) : undefined; if (baseConstructorType.symbol && baseConstructorType.symbol.flags & SymbolFlags.Class && @@ -6390,7 +6389,7 @@ namespace ts { // When base constructor type is a class with no captured type arguments we know that the constructors all have the same type parameters as the // class and all return the instance type of the class. There is no need for further checks and we can apply the // type arguments in the same manner as a type reference to get the same error reporting experience. - baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol, typeArgs); + baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol); } else if (baseConstructorType.flags & TypeFlags.Any) { baseType = baseConstructorType; @@ -9115,7 +9114,7 @@ namespace ts { return type; } - function createDeferredTypeReference(target: GenericType, node: ArrayTypeNode | TupleTypeNode, mapper?: TypeMapper): DeferredTypeReference { + function createDeferredTypeReference(target: GenericType, node: TypeReferenceNode | ArrayTypeNode | TupleTypeNode, mapper?: TypeMapper): DeferredTypeReference { const aliasSymbol = getAliasSymbolForTypeNode(node); const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); const type = createObjectType(ObjectFlags.Reference, target.symbol); @@ -9129,7 +9128,11 @@ namespace ts { function getTypeArguments(type: TypeReference): ReadonlyArray { if (!type.resolvedTypeArguments) { - const typeArguments = type.node ? map(type.node.kind === SyntaxKind.ArrayType ? [type.node.elementType] : type.node.elementTypes, getTypeFromTypeNode) : emptyArray; + const node = type.node; + const typeArguments = !node ? emptyArray : + node.kind === SyntaxKind.TypeReference ? concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments(node, type.target.localTypeParameters!)) : + node.kind === SyntaxKind.ArrayType ? [getTypeFromTypeNode(node.elementType)] : + map(node.elementTypes, getTypeFromTypeNode); type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments; } return type.resolvedTypeArguments; @@ -9139,10 +9142,11 @@ namespace ts { return length(type.target.typeParameters); } + /** * Get type from type-reference that reference to class or interface */ - function getTypeFromClassOrInterfaceReference(node: NodeWithTypeArguments, symbol: Symbol, typeArgs: Type[] | undefined): Type { + function getTypeFromClassOrInterfaceReference(node: NodeWithTypeArguments, symbol: Symbol): Type { const type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol)); const typeParameters = type.localTypeParameters; if (typeParameters) { @@ -9166,10 +9170,13 @@ namespace ts { return errorType; } } + if (node.kind === SyntaxKind.TypeReference && isAliasedType(node)) { + return createDeferredTypeReference(type, node, /*mapper*/ undefined); + } // In a type reference, the outer type parameters of the referenced class or interface are automatically // supplied as type arguments and the type reference only specifies arguments for the local type parameters // of the class or interface. - const typeArguments = concatenate(type.outerTypeParameters, fillMissingTypeArguments(typeArgs, typeParameters, minTypeArgumentCount, isJs)); + const typeArguments = concatenate(type.outerTypeParameters, fillMissingTypeArguments(typeArgumentsFromTypeReferenceNode(node), typeParameters, minTypeArgumentCount, isJs)); return createTypeReference(type, typeArguments); } return checkNoTypeArguments(node, symbol) ? type : errorType; @@ -9192,7 +9199,7 @@ namespace ts { * references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the * declared type. Instantiations are cached using the type identities of the type arguments as the key. */ - function getTypeFromTypeAliasReference(node: NodeWithTypeArguments, symbol: Symbol, typeArguments: Type[] | undefined): Type { + function getTypeFromTypeAliasReference(node: NodeWithTypeArguments, symbol: Symbol): Type { const type = getDeclaredTypeOfSymbol(symbol); const typeParameters = getSymbolLinks(symbol).typeParameters; if (typeParameters) { @@ -9208,7 +9215,7 @@ namespace ts { typeParameters.length); return errorType; } - return getTypeAliasInstantiation(symbol, typeArguments); + return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node)); } return checkNoTypeArguments(node, symbol) ? type : errorType; } @@ -9239,19 +9246,16 @@ namespace ts { } function getTypeReferenceType(node: NodeWithTypeArguments, symbol: Symbol): Type { - const typeArguments = typeArgumentsFromTypeReferenceNode(node); // Do unconditionally so we mark type arguments as referenced. if (symbol === unknownSymbol) { return errorType; } symbol = getExpandoSymbol(symbol) || symbol; - if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) { - return getTypeFromClassOrInterfaceReference(node, symbol, typeArguments); + return getTypeFromClassOrInterfaceReference(node, symbol); } if (symbol.flags & SymbolFlags.TypeAlias) { - return getTypeFromTypeAliasReference(node, symbol, typeArguments); + return getTypeFromTypeAliasReference(node, symbol); } - // Get type from reference to named type that cannot be generic (enum or type parameter) const res = tryGetDeclaredTypeOfSymbol(symbol); if (res) { @@ -9259,7 +9263,6 @@ namespace ts { res.flags & TypeFlags.TypeParameter ? getConstrainedTypeVariable(res, node) : getRegularTypeOfLiteralType(res) : errorType; } - if (symbol.flags & SymbolFlags.Value && isJSDocTypeReference(node)) { const jsdocType = getTypeFromJSAlias(node, symbol); if (jsdocType) { @@ -9271,7 +9274,6 @@ namespace ts { return getTypeOfSymbol(symbol); } } - return errorType; } @@ -26100,16 +26102,13 @@ namespace ts { if (node.kind === SyntaxKind.TypeReference && node.typeName.jsdocDotPos !== undefined && !isInJSFile(node) && !isInJSDoc(node)) { grammarErrorAtPos(node, node.typeName.jsdocDotPos, 1, Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments); } + forEach(node.typeArguments, checkSourceElement); const type = getTypeFromTypeReference(node); if (type !== errorType) { - if (node.typeArguments) { - // Do type argument local checks only if referenced type is successfully resolved - forEach(node.typeArguments, checkSourceElement); - if (produceDiagnostics) { - const typeParameters = getTypeParametersForTypeReference(node); - if (typeParameters) { - checkTypeArgumentConstraints(node, typeParameters); - } + if (node.typeArguments && produceDiagnostics) { + const typeParameters = getTypeParametersForTypeReference(node); + if (typeParameters) { + checkTypeArgumentConstraints(node, typeParameters); } } if (type.flags & TypeFlags.Enum && getNodeLinks(node).resolvedSymbol!.flags & SymbolFlags.EnumMember) { @@ -29333,6 +29332,7 @@ namespace ts { const baseTypeNode = getEffectiveBaseTypeNode(node); if (baseTypeNode) { + forEach(baseTypeNode.typeArguments, checkSourceElement); if (languageVersion < ScriptTarget.ES2015) { checkExternalEmitHelpers(baseTypeNode.parent, ExternalEmitHelpers.Extends); } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 21f09ffcd5c38..0466e75b3c473 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -4202,18 +4202,18 @@ namespace ts { */ export interface TypeReference extends ObjectType { target: GenericType; // Type reference target - node?: ArrayTypeNode | TupleTypeNode; + node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode; /* @internal */ mapper?: TypeMapper; /* @internal */ - resolvedTypeArguments?: ReadonlyArray; // Resolved ype reference type arguments + resolvedTypeArguments?: ReadonlyArray; // Resolved type reference type arguments /* @internal */ literalType?: TypeReference; // Clone of type with ObjectFlags.ArrayLiteral set } export interface DeferredTypeReference extends TypeReference { /* @internal */ - node: ArrayTypeNode | TupleTypeNode; + node: TypeReferenceNode | ArrayTypeNode | TupleTypeNode; /* @internal */ mapper?: TypeMapper; } From 81bfa6f2e054e06a60e8edb105a5275bea0088d9 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 30 Aug 2019 07:58:04 -0700 Subject: [PATCH 15/25] Accept new baselines --- .../reference/api/tsserverlibrary.d.ts | 2 +- tests/baselines/reference/api/typescript.d.ts | 2 +- .../reference/asyncAliasReturnType_es5.types | 4 +-- .../reference/asyncAliasReturnType_es6.types | 4 +-- .../reference/asyncAwait_es2017.types | 32 +++++++++---------- .../baselines/reference/asyncAwait_es5.types | 32 +++++++++---------- .../baselines/reference/asyncAwait_es6.types | 32 +++++++++---------- ...ndexesOfIntersectionsAreInferencable.types | 6 ++-- ...appedTypeWithConditionalIsResolvable.types | 4 +-- ...clarationsForIndirectTypeAliasReference.js | 4 +-- ...rationsForIndirectTypeAliasReference.types | 12 +++---- ...estructuringParameterDeclaration3ES5.types | 12 +++---- ...ringParameterDeclaration3ES5iterable.types | 12 +++---- ...estructuringParameterDeclaration3ES6.types | 12 +++---- .../destructuringParameterDeclaration4.types | 4 +-- ...ectDependenceBetweenTypeAliases.errors.txt | 17 +--------- .../directDependenceBetweenTypeAliases.types | 12 +++---- .../reference/genericDefaultsErrors.types | 4 +-- .../reference/genericTypeAliases.types | 2 +- .../reference/mappedTypesArraysTuples.types | 2 +- .../reactSFCAndFunctionResolvable.types | 20 ++++++------ .../reference/readonlyArraysAndTuples.types | 4 +-- .../reference/readonlyArraysAndTuples2.types | 4 +-- .../reference/specedNoStackBlown.types | 2 +- ...dexOnExistingReadonlyFieldIsNotNever.types | 26 +++++++-------- .../transformNestedGeneratorsWithTry.types | 16 +++++----- ...ropsInferenceSucceedsOnIntersections.types | 2 +- ...xStatelessFunctionComponentOverload5.types | 2 +- ...xStatelessFunctionComponentOverload6.types | 2 +- ...tiatedWithDefaultWhenCheckingDefault.types | 4 +-- 30 files changed, 139 insertions(+), 154 deletions(-) diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index c70f389e21073..c6601d8d37db0 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -2351,7 +2351,7 @@ declare namespace ts { */ export interface TypeReference extends ObjectType { target: GenericType; - node?: ArrayTypeNode | TupleTypeNode; + node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode; } export interface DeferredTypeReference extends TypeReference { } diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index c7b96ded9b289..de30e55598860 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -2351,7 +2351,7 @@ declare namespace ts { */ export interface TypeReference extends ObjectType { target: GenericType; - node?: ArrayTypeNode | TupleTypeNode; + node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode; } export interface DeferredTypeReference extends TypeReference { } diff --git a/tests/baselines/reference/asyncAliasReturnType_es5.types b/tests/baselines/reference/asyncAliasReturnType_es5.types index 87090b795e309..22ca9c932b303 100644 --- a/tests/baselines/reference/asyncAliasReturnType_es5.types +++ b/tests/baselines/reference/asyncAliasReturnType_es5.types @@ -1,7 +1,7 @@ === tests/cases/conformance/async/es5/asyncAliasReturnType_es5.ts === type PromiseAlias = Promise; ->PromiseAlias : Promise +>PromiseAlias : PromiseAlias async function f(): PromiseAlias { ->f : () => Promise +>f : () => PromiseAlias } diff --git a/tests/baselines/reference/asyncAliasReturnType_es6.types b/tests/baselines/reference/asyncAliasReturnType_es6.types index 85d74896056dd..943856611b568 100644 --- a/tests/baselines/reference/asyncAliasReturnType_es6.types +++ b/tests/baselines/reference/asyncAliasReturnType_es6.types @@ -1,7 +1,7 @@ === tests/cases/conformance/async/es6/asyncAliasReturnType_es6.ts === type PromiseAlias = Promise; ->PromiseAlias : Promise +>PromiseAlias : PromiseAlias async function f(): PromiseAlias { ->f : () => Promise +>f : () => PromiseAlias } diff --git a/tests/baselines/reference/asyncAwait_es2017.types b/tests/baselines/reference/asyncAwait_es2017.types index 4d657ab2ca386..c3fecf0f7c8cc 100644 --- a/tests/baselines/reference/asyncAwait_es2017.types +++ b/tests/baselines/reference/asyncAwait_es2017.types @@ -1,6 +1,6 @@ === tests/cases/conformance/async/es2017/asyncAwait_es2017.ts === type MyPromise = Promise; ->MyPromise : Promise +>MyPromise : MyPromise declare var MyPromise: typeof Promise; >MyPromise : PromiseConstructor @@ -10,7 +10,7 @@ declare var p: Promise; >p : Promise declare var mp: MyPromise; ->mp : Promise +>mp : MyPromise async function f0() { } >f0 : () => Promise @@ -19,7 +19,7 @@ async function f1(): Promise { } >f1 : () => Promise async function f3(): MyPromise { } ->f3 : () => Promise +>f3 : () => MyPromise let f4 = async function() { } >f4 : () => Promise @@ -30,8 +30,8 @@ let f5 = async function(): Promise { } >async function(): Promise { } : () => Promise let f6 = async function(): MyPromise { } ->f6 : () => Promise ->async function(): MyPromise { } : () => Promise +>f6 : () => MyPromise +>async function(): MyPromise { } : () => MyPromise let f7 = async () => { }; >f7 : () => Promise @@ -42,8 +42,8 @@ let f8 = async (): Promise => { }; >async (): Promise => { } : () => Promise let f9 = async (): MyPromise => { }; ->f9 : () => Promise ->async (): MyPromise => { } : () => Promise +>f9 : () => MyPromise +>async (): MyPromise => { } : () => MyPromise let f10 = async () => p; >f10 : () => Promise @@ -53,21 +53,21 @@ let f10 = async () => p; let f11 = async () => mp; >f11 : () => Promise >async () => mp : () => Promise ->mp : Promise +>mp : MyPromise let f12 = async (): Promise => mp; >f12 : () => Promise >async (): Promise => mp : () => Promise ->mp : Promise +>mp : MyPromise let f13 = async (): MyPromise => p; ->f13 : () => Promise ->async (): MyPromise => p : () => Promise +>f13 : () => MyPromise +>async (): MyPromise => p : () => MyPromise >p : Promise let o = { ->o : { m1(): Promise; m2(): Promise; m3(): Promise; } ->{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): Promise; } +>o : { m1(): Promise; m2(): Promise; m3(): MyPromise; } +>{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): MyPromise; } async m1() { }, >m1 : () => Promise @@ -76,7 +76,7 @@ let o = { >m2 : () => Promise async m3(): MyPromise { } ->m3 : () => Promise +>m3 : () => MyPromise }; @@ -90,7 +90,7 @@ class C { >m2 : () => Promise async m3(): MyPromise { } ->m3 : () => Promise +>m3 : () => MyPromise static async m4() { } >m4 : () => Promise @@ -99,7 +99,7 @@ class C { >m5 : () => Promise static async m6(): MyPromise { } ->m6 : () => Promise +>m6 : () => MyPromise } module M { diff --git a/tests/baselines/reference/asyncAwait_es5.types b/tests/baselines/reference/asyncAwait_es5.types index fb10a6dd043c1..be62067c30181 100644 --- a/tests/baselines/reference/asyncAwait_es5.types +++ b/tests/baselines/reference/asyncAwait_es5.types @@ -1,6 +1,6 @@ === tests/cases/conformance/async/es5/asyncAwait_es5.ts === type MyPromise = Promise; ->MyPromise : Promise +>MyPromise : MyPromise declare var MyPromise: typeof Promise; >MyPromise : PromiseConstructor @@ -10,7 +10,7 @@ declare var p: Promise; >p : Promise declare var mp: MyPromise; ->mp : Promise +>mp : MyPromise async function f0() { } >f0 : () => Promise @@ -19,7 +19,7 @@ async function f1(): Promise { } >f1 : () => Promise async function f3(): MyPromise { } ->f3 : () => Promise +>f3 : () => MyPromise let f4 = async function() { } >f4 : () => Promise @@ -30,8 +30,8 @@ let f5 = async function(): Promise { } >async function(): Promise { } : () => Promise let f6 = async function(): MyPromise { } ->f6 : () => Promise ->async function(): MyPromise { } : () => Promise +>f6 : () => MyPromise +>async function(): MyPromise { } : () => MyPromise let f7 = async () => { }; >f7 : () => Promise @@ -42,8 +42,8 @@ let f8 = async (): Promise => { }; >async (): Promise => { } : () => Promise let f9 = async (): MyPromise => { }; ->f9 : () => Promise ->async (): MyPromise => { } : () => Promise +>f9 : () => MyPromise +>async (): MyPromise => { } : () => MyPromise let f10 = async () => p; >f10 : () => Promise @@ -53,21 +53,21 @@ let f10 = async () => p; let f11 = async () => mp; >f11 : () => Promise >async () => mp : () => Promise ->mp : Promise +>mp : MyPromise let f12 = async (): Promise => mp; >f12 : () => Promise >async (): Promise => mp : () => Promise ->mp : Promise +>mp : MyPromise let f13 = async (): MyPromise => p; ->f13 : () => Promise ->async (): MyPromise => p : () => Promise +>f13 : () => MyPromise +>async (): MyPromise => p : () => MyPromise >p : Promise let o = { ->o : { m1(): Promise; m2(): Promise; m3(): Promise; } ->{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): Promise; } +>o : { m1(): Promise; m2(): Promise; m3(): MyPromise; } +>{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): MyPromise; } async m1() { }, >m1 : () => Promise @@ -76,7 +76,7 @@ let o = { >m2 : () => Promise async m3(): MyPromise { } ->m3 : () => Promise +>m3 : () => MyPromise }; @@ -90,7 +90,7 @@ class C { >m2 : () => Promise async m3(): MyPromise { } ->m3 : () => Promise +>m3 : () => MyPromise static async m4() { } >m4 : () => Promise @@ -99,7 +99,7 @@ class C { >m5 : () => Promise static async m6(): MyPromise { } ->m6 : () => Promise +>m6 : () => MyPromise } module M { diff --git a/tests/baselines/reference/asyncAwait_es6.types b/tests/baselines/reference/asyncAwait_es6.types index cd9a05ee48ef1..3933b9ce7daad 100644 --- a/tests/baselines/reference/asyncAwait_es6.types +++ b/tests/baselines/reference/asyncAwait_es6.types @@ -1,6 +1,6 @@ === tests/cases/conformance/async/es6/asyncAwait_es6.ts === type MyPromise = Promise; ->MyPromise : Promise +>MyPromise : MyPromise declare var MyPromise: typeof Promise; >MyPromise : PromiseConstructor @@ -10,7 +10,7 @@ declare var p: Promise; >p : Promise declare var mp: MyPromise; ->mp : Promise +>mp : MyPromise async function f0() { } >f0 : () => Promise @@ -19,7 +19,7 @@ async function f1(): Promise { } >f1 : () => Promise async function f3(): MyPromise { } ->f3 : () => Promise +>f3 : () => MyPromise let f4 = async function() { } >f4 : () => Promise @@ -30,8 +30,8 @@ let f5 = async function(): Promise { } >async function(): Promise { } : () => Promise let f6 = async function(): MyPromise { } ->f6 : () => Promise ->async function(): MyPromise { } : () => Promise +>f6 : () => MyPromise +>async function(): MyPromise { } : () => MyPromise let f7 = async () => { }; >f7 : () => Promise @@ -42,8 +42,8 @@ let f8 = async (): Promise => { }; >async (): Promise => { } : () => Promise let f9 = async (): MyPromise => { }; ->f9 : () => Promise ->async (): MyPromise => { } : () => Promise +>f9 : () => MyPromise +>async (): MyPromise => { } : () => MyPromise let f10 = async () => p; >f10 : () => Promise @@ -53,21 +53,21 @@ let f10 = async () => p; let f11 = async () => mp; >f11 : () => Promise >async () => mp : () => Promise ->mp : Promise +>mp : MyPromise let f12 = async (): Promise => mp; >f12 : () => Promise >async (): Promise => mp : () => Promise ->mp : Promise +>mp : MyPromise let f13 = async (): MyPromise => p; ->f13 : () => Promise ->async (): MyPromise => p : () => Promise +>f13 : () => MyPromise +>async (): MyPromise => p : () => MyPromise >p : Promise let o = { ->o : { m1(): Promise; m2(): Promise; m3(): Promise; } ->{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): Promise; } +>o : { m1(): Promise; m2(): Promise; m3(): MyPromise; } +>{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): MyPromise; } async m1() { }, >m1 : () => Promise @@ -76,7 +76,7 @@ let o = { >m2 : () => Promise async m3(): MyPromise { } ->m3 : () => Promise +>m3 : () => MyPromise }; @@ -90,7 +90,7 @@ class C { >m2 : () => Promise async m3(): MyPromise { } ->m3 : () => Promise +>m3 : () => MyPromise static async m4() { } >m4 : () => Promise @@ -99,7 +99,7 @@ class C { >m5 : () => Promise static async m6(): MyPromise { } ->m6 : () => Promise +>m6 : () => MyPromise } module M { diff --git a/tests/baselines/reference/complicatedIndexesOfIntersectionsAreInferencable.types b/tests/baselines/reference/complicatedIndexesOfIntersectionsAreInferencable.types index 64511cb9df284..55d6368e2920f 100644 --- a/tests/baselines/reference/complicatedIndexesOfIntersectionsAreInferencable.types +++ b/tests/baselines/reference/complicatedIndexesOfIntersectionsAreInferencable.types @@ -12,10 +12,10 @@ interface FormikConfig { } declare function Func( ->Func : (x: string extends "validate" | "initialValues" | keyof ExtraProps ? Readonly & ExtraProps> : Pick & ExtraProps>, "validate" | "initialValues" | Exclude> & Partial & ExtraProps>, "validateOnChange" | Extract>>) => void +>Func : (x: string extends keyof ExtraProps | "validate" | "initialValues" ? Readonly & ExtraProps> : Pick & ExtraProps>, Exclude | "validate" | "initialValues"> & Partial & ExtraProps>, "validateOnChange" | Extract>>) => void x: (string extends "validate" | "initialValues" | keyof ExtraProps ->x : string extends "validate" | "initialValues" | keyof ExtraProps ? Readonly & ExtraProps> : Pick & ExtraProps>, "validate" | "initialValues" | Exclude> & Partial & ExtraProps>, "validateOnChange" | Extract>> +>x : string extends keyof ExtraProps | "validate" | "initialValues" ? Readonly & ExtraProps> : Pick & ExtraProps>, Exclude | "validate" | "initialValues"> & Partial & ExtraProps>, "validateOnChange" | Extract>> ? Readonly & ExtraProps> : Pick & ExtraProps>, "validate" | "initialValues" | Exclude> @@ -24,7 +24,7 @@ declare function Func( Func({ >Func({ initialValues: { foo: "" }, validate: props => { props.foo; }}) : void ->Func : (x: string extends "validate" | "initialValues" | keyof ExtraProps ? Readonly & ExtraProps> : Pick & ExtraProps>, "validate" | "initialValues" | Exclude> & Partial & ExtraProps>, "validateOnChange" | Extract>>) => void +>Func : (x: string extends keyof ExtraProps | "validate" | "initialValues" ? Readonly & ExtraProps> : Pick & ExtraProps>, Exclude | "validate" | "initialValues"> & Partial & ExtraProps>, "validateOnChange" | Extract>>) => void >{ initialValues: { foo: "" }, validate: props => { props.foo; }} : { initialValues: { foo: string; }; validate: (props: { foo: string; }) => void; } initialValues: { diff --git a/tests/baselines/reference/constraintOfRecursivelyMappedTypeWithConditionalIsResolvable.types b/tests/baselines/reference/constraintOfRecursivelyMappedTypeWithConditionalIsResolvable.types index b3f5a0e9f91b0..1170aa71c4827 100644 --- a/tests/baselines/reference/constraintOfRecursivelyMappedTypeWithConditionalIsResolvable.types +++ b/tests/baselines/reference/constraintOfRecursivelyMappedTypeWithConditionalIsResolvable.types @@ -6,7 +6,7 @@ interface Map { } export type ImmutableTypes = IImmutableMap; ->ImmutableTypes : IImmutableMap +>ImmutableTypes : ImmutableTypes export type ImmutableModel = { [K in keyof T]: T[K] extends ImmutableTypes ? T[K] : never }; >ImmutableModel : ImmutableModel @@ -19,7 +19,7 @@ export interface IImmutableMap> extends Map; ->ImmutableTypes2 : IImmutableMap2 +>ImmutableTypes2 : ImmutableTypes2 type isImmutableType = [T] extends [ImmutableTypes2] ? T : never; >isImmutableType : isImmutableType diff --git a/tests/baselines/reference/declarationsForIndirectTypeAliasReference.js b/tests/baselines/reference/declarationsForIndirectTypeAliasReference.js index 9e2f9ee40390b..1563e2571cc40 100644 --- a/tests/baselines/reference/declarationsForIndirectTypeAliasReference.js +++ b/tests/baselines/reference/declarationsForIndirectTypeAliasReference.js @@ -61,6 +61,6 @@ declare type StringHash = Hash; interface StringHash2 extends Hash { } //// [a.d.ts] -import { StringHash2 } from "./b"; +import { StringHash, StringHash2 } from "./b"; export { doSome }; -declare function doSome(arg1: string, arg2?: import("./b").Hash, arg3?: StringHash2): void; +declare function doSome(arg1: string, arg2?: StringHash, arg3?: StringHash2): void; diff --git a/tests/baselines/reference/declarationsForIndirectTypeAliasReference.types b/tests/baselines/reference/declarationsForIndirectTypeAliasReference.types index e527a8a3bfa7a..85ebfca651f13 100644 --- a/tests/baselines/reference/declarationsForIndirectTypeAliasReference.types +++ b/tests/baselines/reference/declarationsForIndirectTypeAliasReference.types @@ -15,7 +15,7 @@ interface Hash { } type StringHash = Hash; ->StringHash : Hash +>StringHash : StringHash interface StringHash2 extends Hash {} === tests/cases/compiler/a.ts === @@ -25,11 +25,11 @@ import {StringHash, StringHash2} from "./b"; export { doSome ->doSome : (arg1: string, arg2?: import("tests/cases/compiler/b").Hash, arg3?: StringHash2) => void +>doSome : (arg1: string, arg2?: StringHash, arg3?: StringHash2) => void } const MAP: StringHash = { ->MAP : import("tests/cases/compiler/b").Hash +>MAP : StringHash >{ a: "a"} : { a: string; } a: "a" @@ -49,12 +49,12 @@ const MAP2: StringHash2 = { }; function doSome(arg1: string, ->doSome : (arg1: string, arg2?: import("tests/cases/compiler/b").Hash, arg3?: StringHash2) => void +>doSome : (arg1: string, arg2?: StringHash, arg3?: StringHash2) => void >arg1 : string arg2 = MAP, ->arg2 : import("tests/cases/compiler/b").Hash ->MAP : import("tests/cases/compiler/b").Hash +>arg2 : StringHash +>MAP : StringHash arg3 = MAP2) { >arg3 : StringHash2 diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.types b/tests/baselines/reference/destructuringParameterDeclaration3ES5.types index 96681054bd9e2..a18a2c4f0a960 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.types +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.types @@ -6,13 +6,13 @@ // ... Identifier TypeAnnotation(opt) type arrayString = Array ->arrayString : String[] +>arrayString : arrayString type someArray = Array | number[]; >someArray : someArray type stringOrNumArray = Array; ->stringOrNumArray : (String | Number)[] +>stringOrNumArray : stringOrNumArray function a1(...x: (number|string)[]) { } >a1 : (...x: (string | number)[]) => void @@ -27,12 +27,12 @@ function a3(...a: Array) { } >a : String[] function a4(...a: arrayString) { } ->a4 : (...a: String[]) => void ->a : String[] +>a4 : (...a: arrayString) => void +>a : arrayString function a5(...a: stringOrNumArray) { } ->a5 : (...a: (String | Number)[]) => void ->a : (String | Number)[] +>a5 : (...a: stringOrNumArray) => void +>a : stringOrNumArray function a9([a, b, [[c]]]) { } >a9 : ([a, b, [[c]]]: [any, any, [[any]]]) => void diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types index 441a079e4abb1..e41c2e5d75acf 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5iterable.types @@ -6,13 +6,13 @@ // ... Identifier TypeAnnotation(opt) type arrayString = Array ->arrayString : String[] +>arrayString : arrayString type someArray = Array | number[]; >someArray : someArray type stringOrNumArray = Array; ->stringOrNumArray : (String | Number)[] +>stringOrNumArray : stringOrNumArray function a1(...x: (number|string)[]) { } >a1 : (...x: (string | number)[]) => void @@ -27,12 +27,12 @@ function a3(...a: Array) { } >a : String[] function a4(...a: arrayString) { } ->a4 : (...a: String[]) => void ->a : String[] +>a4 : (...a: arrayString) => void +>a : arrayString function a5(...a: stringOrNumArray) { } ->a5 : (...a: (String | Number)[]) => void ->a : (String | Number)[] +>a5 : (...a: stringOrNumArray) => void +>a : stringOrNumArray function a9([a, b, [[c]]]) { } >a9 : ([a, b, [[c]]]: [any, any, [[any]]]) => void diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.types b/tests/baselines/reference/destructuringParameterDeclaration3ES6.types index a7fcb861e4c1a..4adacfd11ffd2 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.types +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.types @@ -6,13 +6,13 @@ // ... Identifier TypeAnnotation(opt) type arrayString = Array ->arrayString : String[] +>arrayString : arrayString type someArray = Array | number[]; >someArray : someArray type stringOrNumArray = Array; ->stringOrNumArray : (String | Number)[] +>stringOrNumArray : stringOrNumArray function a1(...x: (number|string)[]) { } >a1 : (...x: (string | number)[]) => void @@ -27,12 +27,12 @@ function a3(...a: Array) { } >a : String[] function a4(...a: arrayString) { } ->a4 : (...a: String[]) => void ->a : String[] +>a4 : (...a: arrayString) => void +>a : arrayString function a5(...a: stringOrNumArray) { } ->a5 : (...a: (String | Number)[]) => void ->a : (String | Number)[] +>a5 : (...a: stringOrNumArray) => void +>a : stringOrNumArray function a9([a, b, [[c]]]) { } >a9 : ([a, b, [[c]]]: [any, any, [[any]]]) => void diff --git a/tests/baselines/reference/destructuringParameterDeclaration4.types b/tests/baselines/reference/destructuringParameterDeclaration4.types index 444a70ff1969c..2c3a7dc5f9586 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration4.types +++ b/tests/baselines/reference/destructuringParameterDeclaration4.types @@ -6,13 +6,13 @@ // ... Identifier TypeAnnotation(opt) type arrayString = Array ->arrayString : String[] +>arrayString : arrayString type someArray = Array | number[]; >someArray : someArray type stringOrNumArray = Array; ->stringOrNumArray : (String | Number)[] +>stringOrNumArray : stringOrNumArray function a0(...x: [number, number, string]) { } // Error, rest parameter must be array type >a0 : (x_0: number, x_1: number, x_2: string) => void diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt index 15e654df9a7f2..374cef0c1cb81 100644 --- a/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt @@ -2,17 +2,12 @@ tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts( tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(5,6): error TS2456: Type alias 'T0_1' circularly references itself. tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(6,6): error TS2456: Type alias 'T0_2' circularly references itself. tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(7,6): error TS2456: Type alias 'T0_3' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(11,6): error TS2456: Type alias 'T1' circularly references itself. tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(14,6): error TS2456: Type alias 'T2' circularly references itself. tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(25,5): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(26,6): error TS2456: Type alias 'T5' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(29,6): error TS2456: Type alias 'T6' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(30,6): error TS2456: Type alias 'T7' circularly references itself. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(31,5): error TS2502: 'yy' is referenced directly or indirectly in its own type annotation. -tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(32,6): error TS2456: Type alias 'T8' circularly references itself. -==== tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts (12 errors) ==== +==== tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts (7 errors) ==== // It is an error for the type specified in a type alias to depend on that type alias // A type alias directly depends on the type it aliases. @@ -32,8 +27,6 @@ tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts( // A type reference directly depends on the referenced type and each of the type arguments, if any. interface I {} type T1 = I - ~~ -!!! error TS2456: Type alias 'T1' circularly references itself. // A union type directly depends on each of the constituent types. type T2 = T2 | string @@ -58,17 +51,9 @@ tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts( class C1 {} type T6 = T7 | number - ~~ -!!! error TS2456: Type alias 'T6' circularly references itself. type T7 = typeof yy - ~~ -!!! error TS2456: Type alias 'T7' circularly references itself. var yy: [string, T8[]]; - ~~ -!!! error TS2502: 'yy' is referenced directly or indirectly in its own type annotation. type T8 = C - ~~ -!!! error TS2456: Type alias 'T8' circularly references itself. // legal cases type T9 = () => T9 diff --git a/tests/baselines/reference/directDependenceBetweenTypeAliases.types b/tests/baselines/reference/directDependenceBetweenTypeAliases.types index 1ddbeb019cfc3..e1d6784b327f8 100644 --- a/tests/baselines/reference/directDependenceBetweenTypeAliases.types +++ b/tests/baselines/reference/directDependenceBetweenTypeAliases.types @@ -17,7 +17,7 @@ type T0_3 = T0_1 // A type reference directly depends on the referenced type and each of the type arguments, if any. interface I {} type T1 = I ->T1 : any +>T1 : T1 // A union type directly depends on each of the constituent types. type T2 = T2 | string @@ -50,17 +50,17 @@ class C1 {} >C1 : C1 type T6 = T7 | number ->T6 : any +>T6 : T6 type T7 = typeof yy ->T7 : any ->yy : any +>T7 : [string, T8[]] +>yy : [string, T8[]] var yy: [string, T8[]]; ->yy : any +>yy : [string, T8[]] type T8 = C ->T8 : any +>T8 : T8 // legal cases type T9 = () => T9 diff --git a/tests/baselines/reference/genericDefaultsErrors.types b/tests/baselines/reference/genericDefaultsErrors.types index 51b819f9d0193..5eaf9af1cc1b8 100644 --- a/tests/baselines/reference/genericDefaultsErrors.types +++ b/tests/baselines/reference/genericDefaultsErrors.types @@ -70,10 +70,10 @@ type i09t01 = i09<1>; // error >i09t01 : any type i09t02 = i09<1, 2>; // ok ->i09t02 : i09<1, 2, number> +>i09t02 : i09t02 type i09t03 = i09<1, 2, 3>; // ok ->i09t03 : i09<1, 2, 3> +>i09t03 : i09t03 type i09t04 = i09<1, 2, 3, 4>; // error >i09t04 : any diff --git a/tests/baselines/reference/genericTypeAliases.types b/tests/baselines/reference/genericTypeAliases.types index 308c61da72501..a092c7c8024af 100644 --- a/tests/baselines/reference/genericTypeAliases.types +++ b/tests/baselines/reference/genericTypeAliases.types @@ -143,7 +143,7 @@ interface AB { } type Pair = AB; ->Pair : AB +>Pair : Pair interface TaggedPair extends Pair { tag: string; diff --git a/tests/baselines/reference/mappedTypesArraysTuples.types b/tests/baselines/reference/mappedTypesArraysTuples.types index 6b43cd510fb15..2ec00ad565e3e 100644 --- a/tests/baselines/reference/mappedTypesArraysTuples.types +++ b/tests/baselines/reference/mappedTypesArraysTuples.types @@ -66,7 +66,7 @@ type B = { b: string }; >b : string type T40 = Boxified | [A, B] | string | string[]>; ->T40 : string | Box[] | Boxified | Box[] | readonly Box[] | [Box, Box] +>T40 : string | Box[] | Boxified | readonly Box[] | Box[] | [Box, Box] type ReadWrite = { -readonly [P in keyof T] : T[P] }; >ReadWrite : ReadWrite diff --git a/tests/baselines/reference/reactSFCAndFunctionResolvable.types b/tests/baselines/reference/reactSFCAndFunctionResolvable.types index d8061605b1fc5..d4949fe885018 100644 --- a/tests/baselines/reference/reactSFCAndFunctionResolvable.types +++ b/tests/baselines/reference/reactSFCAndFunctionResolvable.types @@ -14,7 +14,7 @@ declare const OtherRadio: () => React.ReactElement<{}>; >React : any declare const Checkbox: React.SFC; ->Checkbox : React.StatelessComponent<{}> +>Checkbox : React.SFC<{}> >React : any declare const condition1: boolean; @@ -27,43 +27,43 @@ declare const condition3: boolean; >condition3 : boolean const RandomComponent: React.SFC = () => { ->RandomComponent : React.StatelessComponent<{}> +>RandomComponent : React.SFC<{}> >React : any >() => { const Component = condition1 ? Radio : Checkbox; const OtherComponent = condition2 ? OtherRadio : Checkbox; return condition1 ? : ;} : () => JSX.Element const Component = ->Component : React.StatelessComponent<{}> | ((props: {}) => React.ReactElement<{}>) +>Component : ((props: {}) => React.ReactElement<{}>) | React.SFC<{}> condition1 ->condition1 ? Radio : Checkbox : React.StatelessComponent<{}> | ((props: {}) => React.ReactElement<{}>) +>condition1 ? Radio : Checkbox : ((props: {}) => React.ReactElement<{}>) | React.SFC<{}> >condition1 : boolean ? Radio >Radio : (props: {}) => React.ReactElement<{}> : Checkbox; ->Checkbox : React.StatelessComponent<{}> +>Checkbox : React.SFC<{}> const OtherComponent = ->OtherComponent : React.StatelessComponent<{}> | (() => React.ReactElement<{}>) +>OtherComponent : (() => React.ReactElement<{}>) | React.SFC<{}> condition2 ->condition2 ? OtherRadio : Checkbox : React.StatelessComponent<{}> | (() => React.ReactElement<{}>) +>condition2 ? OtherRadio : Checkbox : (() => React.ReactElement<{}>) | React.SFC<{}> >condition2 : boolean ? OtherRadio >OtherRadio : () => React.ReactElement<{}> : Checkbox; ->Checkbox : React.StatelessComponent<{}> +>Checkbox : React.SFC<{}> return condition1 ? : ; >condition1 ? : : JSX.Element >condition1 : boolean > : JSX.Element ->Component : React.StatelessComponent<{}> | ((props: {}) => React.ReactElement<{}>) +>Component : ((props: {}) => React.ReactElement<{}>) | React.SFC<{}> > : JSX.Element ->OtherComponent : React.StatelessComponent<{}> | (() => React.ReactElement<{}>) +>OtherComponent : (() => React.ReactElement<{}>) | React.SFC<{}> }; diff --git a/tests/baselines/reference/readonlyArraysAndTuples.types b/tests/baselines/reference/readonlyArraysAndTuples.types index 2d4086a0193bd..a0db326f35ed3 100644 --- a/tests/baselines/reference/readonlyArraysAndTuples.types +++ b/tests/baselines/reference/readonlyArraysAndTuples.types @@ -3,13 +3,13 @@ type T10 = string[]; >T10 : T10 type T11 = Array; ->T11 : string[] +>T11 : T11 type T12 = readonly string[]; >T12 : readonly string[] type T13 = ReadonlyArray; ->T13 : readonly string[] +>T13 : T13 type T20 = [number, number]; >T20 : T20 diff --git a/tests/baselines/reference/readonlyArraysAndTuples2.types b/tests/baselines/reference/readonlyArraysAndTuples2.types index 7b8c71248067b..be75e04652896 100644 --- a/tests/baselines/reference/readonlyArraysAndTuples2.types +++ b/tests/baselines/reference/readonlyArraysAndTuples2.types @@ -3,13 +3,13 @@ type T10 = string[]; >T10 : T10 type T11 = Array; ->T11 : string[] +>T11 : T11 type T12 = readonly string[]; >T12 : readonly string[] type T13 = ReadonlyArray; ->T13 : readonly string[] +>T13 : T13 type T20 = [number, number]; >T20 : T20 diff --git a/tests/baselines/reference/specedNoStackBlown.types b/tests/baselines/reference/specedNoStackBlown.types index f2ef490fa8098..884c24151a020 100644 --- a/tests/baselines/reference/specedNoStackBlown.types +++ b/tests/baselines/reference/specedNoStackBlown.types @@ -29,7 +29,7 @@ export type Spec = [Predicate, ErrorMs >Spec : Spec export type SpecArray = Array>; ->SpecArray : Spec[] +>SpecArray : SpecArray export type SpecFunction = [INPUT] extends [ReadonlyArray] >SpecFunction : SpecFunction diff --git a/tests/baselines/reference/thisIndexOnExistingReadonlyFieldIsNotNever.types b/tests/baselines/reference/thisIndexOnExistingReadonlyFieldIsNotNever.types index 30dfd635724d1..8f1eff831e305 100644 --- a/tests/baselines/reference/thisIndexOnExistingReadonlyFieldIsNotNever.types +++ b/tests/baselines/reference/thisIndexOnExistingReadonlyFieldIsNotNever.types @@ -15,7 +15,7 @@ interface CoachMarkAnchorProps { >anchor : C } type AnchorType

= Component

; ->AnchorType : Component +>AnchorType : AnchorType

class CoachMarkAnchorDecorator { >CoachMarkAnchorDecorator : CoachMarkAnchorDecorator @@ -27,28 +27,28 @@ class CoachMarkAnchorDecorator { return class CoachMarkAnchor extends Component> & P, {}> { >class CoachMarkAnchor extends Component> & P, {}> { private _onAnchorRef = (anchor: AnchorType

) => { const anchorRef = this.props.anchorRef; if (anchorRef) { anchorRef(anchor); } } } : typeof CoachMarkAnchor >CoachMarkAnchor : typeof CoachMarkAnchor ->Component : Component> & P, {}> +>Component : Component> & P, {}> private _onAnchorRef = (anchor: AnchorType

) => { ->_onAnchorRef : (anchor: Component) => void ->(anchor: AnchorType

) => { const anchorRef = this.props.anchorRef; if (anchorRef) { anchorRef(anchor); } } : (anchor: Component) => void ->anchor : Component +>_onAnchorRef : (anchor: AnchorType

) => void +>(anchor: AnchorType

) => { const anchorRef = this.props.anchorRef; if (anchorRef) { anchorRef(anchor); } } : (anchor: AnchorType

) => void +>anchor : AnchorType

const anchorRef = this.props.anchorRef; ->anchorRef : (CoachMarkAnchorProps> & P)["anchorRef"] | undefined ->this.props.anchorRef : (CoachMarkAnchorProps> & P)["anchorRef"] | undefined ->this.props : Readonly<{ children?: unknown; }> & Readonly> & P> +>anchorRef : (CoachMarkAnchorProps> & P)["anchorRef"] | undefined +>this.props.anchorRef : (CoachMarkAnchorProps> & P)["anchorRef"] | undefined +>this.props : Readonly<{ children?: unknown; }> & Readonly> & P> >this : this ->props : Readonly<{ children?: unknown; }> & Readonly> & P> ->anchorRef : (CoachMarkAnchorProps> & P)["anchorRef"] | undefined +>props : Readonly<{ children?: unknown; }> & Readonly> & P> +>anchorRef : (CoachMarkAnchorProps> & P)["anchorRef"] | undefined if (anchorRef) { ->anchorRef : (CoachMarkAnchorProps> & P)["anchorRef"] | undefined +>anchorRef : (CoachMarkAnchorProps> & P)["anchorRef"] | undefined anchorRef(anchor); >anchorRef(anchor) : void ->anchorRef : (anchor: Component) => void ->anchor : Component +>anchorRef : (anchor: AnchorType

) => void +>anchor : AnchorType

} } }; diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.types b/tests/baselines/reference/transformNestedGeneratorsWithTry.types index 0ea963bbe4aeb..061342eaf44b0 100644 --- a/tests/baselines/reference/transformNestedGeneratorsWithTry.types +++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.types @@ -4,13 +4,13 @@ import * as Bluebird from 'bluebird'; >Bluebird : PromiseConstructor async function a(): Bluebird { ->a : () => Promise +>a : () => Bluebird try { const b = async function b(): Bluebird { ->b : () => Promise ->async function b(): Bluebird { try { await Bluebird.resolve(); // -- remove this and it compiles } catch (error) { } } : () => Promise ->b : () => Promise +>b : () => Bluebird +>async function b(): Bluebird { try { await Bluebird.resolve(); // -- remove this and it compiles } catch (error) { } } : () => Bluebird +>b : () => Bluebird try { await Bluebird.resolve(); // -- remove this and it compiles @@ -27,8 +27,8 @@ async function a(): Bluebird { await b(); // -- or remove this and it compiles >await b() : void ->b() : Promise ->b : () => Promise +>b() : Bluebird +>b : () => Bluebird } catch (error) { } >error : any @@ -39,12 +39,12 @@ declare module "bluebird" { >"bluebird" : typeof import("bluebird") type Bluebird = Promise; ->Bluebird : Promise +>Bluebird : Bluebird const Bluebird: typeof Promise; >Bluebird : PromiseConstructor >Promise : PromiseConstructor export = Bluebird; ->Bluebird : Promise +>Bluebird : Bluebird } diff --git a/tests/baselines/reference/tsxReactPropsInferenceSucceedsOnIntersections.types b/tests/baselines/reference/tsxReactPropsInferenceSucceedsOnIntersections.types index 16b5cd1363673..3fa0b722aa49c 100644 --- a/tests/baselines/reference/tsxReactPropsInferenceSucceedsOnIntersections.types +++ b/tests/baselines/reference/tsxReactPropsInferenceSucceedsOnIntersections.types @@ -25,7 +25,7 @@ interface CustomButtonProps extends ButtonProps { } const CustomButton: React.SFC = props =>