diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d671d0e558ccb..c71b0bb56ff2b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4843,7 +4843,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 && hasRealRestParameter(s) && getTypeOfParameter(s.parameters[0]) === anyArrayType; } return false; } @@ -6268,6 +6268,10 @@ namespace ts { return symbol && withAugmentations ? getMergedSymbol(symbol) : symbol; } + function hasRealRestParameter(signature: Signature): boolean { + return signature.hasRestParameter && isArrayType(getRestConstraintOfSignature(signature)); + } + function isOptionalParameter(node: ParameterDeclaration) { if (hasQuestionToken(node) || isJSDocOptionalParameter(node)) { return true; @@ -6358,6 +6362,15 @@ namespace ts { return typeArguments; } + function getTupleLikeLength(type: Type): number { + Debug.assert(isTupleLikeType(type)); + let length = 0; + while (getPropertyOfObjectType(type, length + "" as __String)) { + length++; + } + return length; + } + function getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature { const links = getNodeLinks(declaration); if (!links.resolvedSignature) { @@ -6402,6 +6415,17 @@ namespace ts { if (!isOptionalParameter) { minArgumentCount = parameters.length; } + + // adjust minimum argument count for tuple-bound rest parameters. could use `length` property given #17765. + if (param.dotDotDotToken) { + // clone symbol as getTypeOfSymbol mutates + const symbol = clone(paramSymbol); + const type = getApparentType(getTypeOfSymbol(symbol)); + if (isTupleLikeType(type)) { + minArgumentCount += getTupleLikeLength(type); + } + } + } // If only one accessor includes a this-type annotation, the other behaves as if it had the same type annotation @@ -6584,12 +6608,25 @@ namespace ts { return !signature.resolvedReturnType && findResolutionCycleStartIndex(signature, TypeSystemPropertyName.ResolvedReturnType) >= 0; } - function getRestTypeOfSignature(signature: Signature): Type { + function getRestConstraintOfSignature(signature: Signature): Type { + Debug.assert(signature.hasRestParameter); + return getTypeOfSymbol(lastOrUndefined(signature.parameters)); + } + + function getRestTypeOfSignature(signature: Signature, pos?: number): Type { + const arrIdx = pos - (signature.parameters.length - 1); if (signature.hasRestParameter) { - const type = getTypeOfSymbol(lastOrUndefined(signature.parameters)); - if (getObjectFlags(type) & ObjectFlags.Reference && (type).target === globalArrayType) { + const type = getRestConstraintOfSignature(signature); + if (isArrayType(type)) { return (type).typeArguments[0]; } + else if (isTupleLikeType(type)) { + const symbol = getPropertyOfObjectType(getApparentType(type), arrIdx + "" as __String); + return symbol ? getIndexedAccessType(type, pos !== undefined ? getLiteralType(arrIdx) : globalNumberType) : neverType; + } + else if (isArrayLikeType(type)) { + return getIndexedAccessType(type, pos !== undefined ? getLiteralType(arrIdx) : globalNumberType); + } } return anyType; } @@ -8550,8 +8587,8 @@ namespace ts { const sourceParams = source.parameters; const targetParams = target.parameters; for (let i = 0; i < checkCount; i++) { - const sourceType = i < sourceMax ? getTypeOfParameter(sourceParams[i]) : getRestTypeOfSignature(source); - const targetType = i < targetMax ? getTypeOfParameter(targetParams[i]) : getRestTypeOfSignature(target); + const sourceType = i < sourceMax ? getTypeOfParameter(sourceParams[i]) : getRestTypeOfSignature(source, i); + const targetType = i < targetMax ? getTypeOfParameter(targetParams[i]) : getRestTypeOfSignature(target, i); const sourceSig = getSingleCallSignature(getNonNullableType(sourceType)); const targetSig = getSingleCallSignature(getNonNullableType(targetType)); // In order to ensure that any generic type Foo is at least co-variant with respect to T no matter @@ -8672,8 +8709,8 @@ namespace ts { } function getNumParametersToCheckForSignatureRelatability(source: Signature, sourceNonRestParamCount: number, target: Signature, targetNonRestParamCount: number) { - if (source.hasRestParameter === target.hasRestParameter) { - if (source.hasRestParameter) { + if (hasRealRestParameter(source) === hasRealRestParameter(target)) { + if (hasRealRestParameter(source)) { // If both have rest parameters, get the max and add 1 to // compensate for the rest parameter. return Math.max(sourceNonRestParamCount, targetNonRestParamCount) + 1; @@ -8684,7 +8721,7 @@ namespace ts { } else { // Return the count for whichever signature doesn't have rest parameters. - return source.hasRestParameter ? + return hasRealRestParameter(source) ? targetNonRestParamCount : sourceNonRestParamCount; } @@ -9928,14 +9965,14 @@ namespace ts { // optional, and rest parameters. if (source.parameters.length === target.parameters.length && source.minArgumentCount === target.minArgumentCount && - source.hasRestParameter === target.hasRestParameter) { + hasRealRestParameter(source) === hasRealRestParameter(target)) { return true; } // A source signature partially matches a target signature if the target signature has no fewer required // parameters and no more overall parameters than the source signature (where a signature with a rest // parameter is always considered to have more overall parameters than one without). - const sourceRestCount = source.hasRestParameter ? 1 : 0; - const targetRestCount = target.hasRestParameter ? 1 : 0; + const sourceRestCount = hasRealRestParameter(source) ? 1 : 0; + const targetRestCount = hasRealRestParameter(target) ? 1 : 0; if (partialMatch && source.minArgumentCount <= target.minArgumentCount && ( sourceRestCount > targetRestCount || sourceRestCount === targetRestCount && source.parameters.length >= target.parameters.length)) { @@ -9985,8 +10022,8 @@ namespace ts { const targetLen = target.parameters.length; for (let i = 0; i < targetLen; i++) { - const s = isRestParameterIndex(source, i) ? getRestTypeOfSignature(source) : getTypeOfParameter(source.parameters[i]); - const t = isRestParameterIndex(target, i) ? getRestTypeOfSignature(target) : getTypeOfParameter(target.parameters[i]); + const s = isRestParameterIndex(source, i) ? getRestTypeOfSignature(source, i) : getTypeOfParameter(source.parameters[i]); + const t = isRestParameterIndex(target, i) ? getRestTypeOfSignature(target, i) : getTypeOfParameter(target.parameters[i]); const related = compareTypes(s, t); if (!related) { return Ternary.False; @@ -10000,7 +10037,7 @@ namespace ts { } function isRestParameterIndex(signature: Signature, parameterIndex: number) { - return signature.hasRestParameter && parameterIndex >= signature.parameters.length - 1; + return hasRealRestParameter(signature) && parameterIndex >= signature.parameters.length - 1; } function literalTypesWithSameBaseType(types: Type[]): boolean { @@ -10334,13 +10371,13 @@ namespace ts { const sourceMax = source.parameters.length; const targetMax = target.parameters.length; let count: number; - if (source.hasRestParameter && target.hasRestParameter) { + if (hasRealRestParameter(source) && hasRealRestParameter(target)) { count = Math.max(sourceMax, targetMax); } - else if (source.hasRestParameter) { + else if (hasRealRestParameter(source)) { count = targetMax; } - else if (target.hasRestParameter) { + else if (hasRealRestParameter(target)) { count = sourceMax; } else { @@ -10634,6 +10671,10 @@ namespace ts { if (type === inference.typeParameter) { return inference; } + else if ((type as IndexedAccessType).objectType === inference.typeParameter && + isTypeInstanceOf((type as IndexedAccessType).indexType, globalNumberType)) { + return inference; + } } } return undefined; @@ -10774,8 +10815,10 @@ namespace ts { const baseCandidates = widenLiteralTypes ? sameMap(inference.candidates, getWidenedLiteralType) : inference.candidates; // Infer widened union or supertype, or the unknown type for no common supertype. We infer union types // for inferences coming from return types in order to avoid common supertype failures. + const candidates = (inference.typeParameter === (signature.hasRestParameter ? getRestConstraintOfSignature(signature) : undefined)) ? + [createTupleType(baseCandidates)] : baseCandidates; const unionOrSuperType = context.flags & InferenceFlags.InferUnionTypes || inference.priority & InferencePriority.ReturnType ? - getUnionType(baseCandidates, /*subtypeReduction*/ true) : getCommonSupertype(baseCandidates); + getUnionType(candidates, /*subtypeReduction*/ true) : getCommonSupertype(candidates); inferredType = getWidenedType(unionOrSuperType); } else if (context.flags & InferenceFlags.NoDefault) { @@ -13289,7 +13332,7 @@ namespace ts { if (target.parameters.length && parameterIsThisKeyword(target.parameters[0])) { targetParameterCount--; } - const sourceLength = signature.hasRestParameter ? Number.MAX_VALUE : signature.parameters.length; + const sourceLength = hasRealRestParameter(signature) ? Number.MAX_VALUE : signature.parameters.length; return sourceLength < targetParameterCount; } @@ -15164,11 +15207,17 @@ namespace ts { // If spread arguments are present, check that they correspond to a rest parameter. If so, no // further checking is necessary. if (spreadArgIndex >= 0) { - return isRestParameterIndex(signature, spreadArgIndex) || spreadArgIndex >= signature.minArgumentCount; + return hasRealRestParameter(signature) && isRestParameterIndex(signature, spreadArgIndex) || spreadArgIndex >= signature.minArgumentCount; } // Too many arguments implies incorrect arity. - if (!signature.hasRestParameter && argCount > signature.parameters.length) { + if (signature.hasRestParameter) { + const type = getApparentType(getRestConstraintOfSignature(signature)); + if (isTupleLikeType(type) && argCount !== signature.parameters.length - 1 + getTupleLikeLength(type)) { + return false; + } + } + else if (argCount > signature.parameters.length) { return false; } @@ -15870,7 +15919,7 @@ namespace ts { min = Math.min(min, sig.minArgumentCount); max = Math.max(max, sig.parameters.length); } - const hasRestParameter = some(signatures, sig => sig.hasRestParameter); + const hasRestParameter = some(signatures, sig => hasRealRestParameter(sig)); const hasSpreadArgument = getSpreadArgumentIndex(args) > -1; const paramCount = hasRestParameter ? min : min < max ? `${min}-${max}` : @@ -15990,7 +16039,7 @@ namespace ts { for (let i = 0; i < candidates.length; i++) { const candidate = candidates[i]; - if (candidate.hasRestParameter || candidate.parameters.length >= argsCount) { + if (hasRealRestParameter(candidate) || candidate.parameters.length >= argsCount) { return i; } if (candidate.parameters.length > maxParams) { @@ -16604,7 +16653,7 @@ namespace ts { function getTypeAtPosition(signature: Signature, pos: number): Type { return signature.hasRestParameter ? - pos < signature.parameters.length - 1 ? getTypeOfParameter(signature.parameters[pos]) : getRestTypeOfSignature(signature) : + pos < signature.parameters.length - 1 ? getTypeOfParameter(signature.parameters[pos]) : getRestTypeOfSignature(signature, pos) : pos < signature.parameters.length ? getTypeOfParameter(signature.parameters[pos]) : anyType; } @@ -16613,7 +16662,7 @@ namespace ts { } function inferFromAnnotatedParameters(signature: Signature, context: Signature, mapper: TypeMapper) { - const len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0); + const len = signature.parameters.length - (hasRealRestParameter(signature) ? 1 : 0); for (let i = 0; i < len; i++) { const declaration = signature.parameters[i].valueDeclaration; if (declaration.type) { @@ -16636,7 +16685,7 @@ namespace ts { assignTypeToParameterAndFixTypeParameters(signature.thisParameter, getTypeOfSymbol(context.thisParameter)); } } - const len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0); + const len = signature.parameters.length - (hasRealRestParameter(signature) ? 1 : 0); for (let i = 0; i < len; i++) { const parameter = signature.parameters[i]; if (!getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) { @@ -18148,7 +18197,7 @@ namespace ts { } } - function checkParameter(node: ParameterDeclaration) { + function checkParameter(node: ParameterDeclaration, hasOptionals = false) { // Grammar checking // It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the // Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code @@ -18179,8 +18228,14 @@ namespace ts { // Only check rest parameter type if it's not a binding pattern. Since binding patterns are // not allowed in a rest parameter, we already have an error from checkGrammarParameterList. - if (node.dotDotDotToken && !isBindingPattern(node.name) && !isArrayType(getTypeOfSymbol(node.symbol))) { - error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type); + const type = getTypeOfSymbol(node.symbol); + if (node.dotDotDotToken && !isBindingPattern(node.name)) { + if (!isArrayLikeType(type) || type === anyType) { + error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type); + } + else if (hasOptionals && !isArrayType(getTypeOfSymbol(node.symbol))) { + error(node, Diagnostics.A_rest_parameter_in_a_function_with_optional_parameters_must_be_of_an_array_type); + } } } @@ -18322,7 +18377,8 @@ namespace ts { checkTypeParameters(node.typeParameters); - forEach(node.parameters, checkParameter); + const hasOptionals = node.parameters.some((par: ParameterDeclaration) => !!par.questionToken); + forEach(node.parameters, (par: ParameterDeclaration) => checkParameter(par, hasOptionals)); // TODO(rbuckton): Should we start checking JSDoc types? if (node.type) { diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 9a3492e5c377a..846b48706e053 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1920,6 +1920,10 @@ "category": "Error", "code": 2562 }, + "A rest parameter in a function with optional parameters must be of an array type.": { + "category": "Error", + "code": 2563 + }, "JSX element attributes type '{0}' may not be a union type.": { "category": "Error", "code": 2600 diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt index 6efd10dce099f..58bc39e785680 100644 --- a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt +++ b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt @@ -1,14 +1,17 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,16): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. +tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,20): error TS2523: 'yield' expressions cannot be used in a parameter initializer. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,26): error TS1005: ',' expected. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS1138: Parameter declaration expected. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS2304: Cannot find name 'yield'. tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,34): error TS1005: ';' expected. -==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (5 errors) ==== +==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (6 errors) ==== function * foo(a = yield => yield) { ~~~~~~~~~ !!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. + ~~~~~ +!!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. ~~ !!! error TS1005: ',' expected. ~~~~~ diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es2017.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es2017.errors.txt index 33cd913a2eb8b..841e1ef22d0b9 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es2017.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es2017.errors.txt @@ -1,4 +1,5 @@ tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,20): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. +tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,30): error TS1109: Expression expected. tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,33): error TS1138: Parameter declaration expected. tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,33): error TS2304: Cannot find name 'await'. @@ -8,10 +9,12 @@ tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclarati tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts(1,53): error TS1109: Expression expected. -==== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts (8 errors) ==== +==== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts (9 errors) ==== async function foo(a = await => await): Promise { ~~~~~~~~~ !!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. + ~~~~~ +!!! error TS2524: 'await' expressions cannot be used in a parameter initializer. ~~ !!! error TS1109: Expression expected. ~~~~~ diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es5.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es5.errors.txt index b974eacd88212..9d5b8bfd5f690 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es5.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es5.errors.txt @@ -1,4 +1,5 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,20): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. +tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,30): error TS1109: Expression expected. tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,33): error TS1138: Parameter declaration expected. tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,33): error TS2304: Cannot find name 'await'. @@ -8,10 +9,12 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts(1,53): error TS1109: Expression expected. -==== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts (8 errors) ==== +==== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts (9 errors) ==== async function foo(a = await => await): Promise { ~~~~~~~~~ !!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. + ~~~~~ +!!! error TS2524: 'await' expressions cannot be used in a parameter initializer. ~~ !!! error TS1109: Expression expected. ~~~~~ diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt index b752ec94a45a0..19e5339dd5a80 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt @@ -1,4 +1,5 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,20): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,24): error TS2524: 'await' expressions cannot be used in a parameter initializer. tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,30): error TS1109: Expression expected. tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS1138: Parameter declaration expected. tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS2304: Cannot find name 'await'. @@ -8,10 +9,12 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,53): error TS1109: Expression expected. -==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts (8 errors) ==== +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts (9 errors) ==== async function foo(a = await => await): Promise { ~~~~~~~~~ !!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation. + ~~~~~ +!!! error TS2524: 'await' expressions cannot be used in a parameter initializer. ~~ !!! error TS1109: Expression expected. ~~~~~ diff --git a/tests/baselines/reference/destructureGenerics.js b/tests/baselines/reference/destructureGenerics.js new file mode 100644 index 0000000000000..1c461f57b30dc --- /dev/null +++ b/tests/baselines/reference/destructureGenerics.js @@ -0,0 +1,19 @@ +//// [destructureGenerics.ts] +declare function f(...args: T): T; +var x = f(1,2); +var x: [1, 2]; +declare function g(...args: T): T; +var z = g(1,2); +var z: [1,2]; +declare function h(...args: T[]): T; +var b = h(1,2,3); +var b: number; + + +//// [destructureGenerics.js] +var x = f(1, 2); +var x; +var z = g(1, 2); +var z; +var b = h(1, 2, 3); +var b; diff --git a/tests/baselines/reference/destructureGenerics.symbols b/tests/baselines/reference/destructureGenerics.symbols new file mode 100644 index 0000000000000..b3c1f6122fdb5 --- /dev/null +++ b/tests/baselines/reference/destructureGenerics.symbols @@ -0,0 +1,43 @@ +=== tests/cases/compiler/destructureGenerics.ts === +declare function f(...args: T): T; +>f : Symbol(f, Decl(destructureGenerics.ts, 0, 0)) +>T : Symbol(T, Decl(destructureGenerics.ts, 0, 19)) +>args : Symbol(args, Decl(destructureGenerics.ts, 0, 36)) +>T : Symbol(T, Decl(destructureGenerics.ts, 0, 19)) +>T : Symbol(T, Decl(destructureGenerics.ts, 0, 19)) + +var x = f(1,2); +>x : Symbol(x, Decl(destructureGenerics.ts, 1, 3), Decl(destructureGenerics.ts, 2, 3)) +>f : Symbol(f, Decl(destructureGenerics.ts, 0, 0)) + +var x: [1, 2]; +>x : Symbol(x, Decl(destructureGenerics.ts, 1, 3), Decl(destructureGenerics.ts, 2, 3)) + +declare function g(...args: T): T; +>g : Symbol(g, Decl(destructureGenerics.ts, 2, 14)) +>T : Symbol(T, Decl(destructureGenerics.ts, 3, 19)) +>args : Symbol(args, Decl(destructureGenerics.ts, 3, 47)) +>T : Symbol(T, Decl(destructureGenerics.ts, 3, 19)) +>T : Symbol(T, Decl(destructureGenerics.ts, 3, 19)) + +var z = g(1,2); +>z : Symbol(z, Decl(destructureGenerics.ts, 4, 3), Decl(destructureGenerics.ts, 5, 3)) +>g : Symbol(g, Decl(destructureGenerics.ts, 2, 14)) + +var z: [1,2]; +>z : Symbol(z, Decl(destructureGenerics.ts, 4, 3), Decl(destructureGenerics.ts, 5, 3)) + +declare function h(...args: T[]): T; +>h : Symbol(h, Decl(destructureGenerics.ts, 5, 13)) +>T : Symbol(T, Decl(destructureGenerics.ts, 6, 19)) +>args : Symbol(args, Decl(destructureGenerics.ts, 6, 22)) +>T : Symbol(T, Decl(destructureGenerics.ts, 6, 19)) +>T : Symbol(T, Decl(destructureGenerics.ts, 6, 19)) + +var b = h(1,2,3); +>b : Symbol(b, Decl(destructureGenerics.ts, 7, 3), Decl(destructureGenerics.ts, 8, 3)) +>h : Symbol(h, Decl(destructureGenerics.ts, 5, 13)) + +var b: number; +>b : Symbol(b, Decl(destructureGenerics.ts, 7, 3), Decl(destructureGenerics.ts, 8, 3)) + diff --git a/tests/baselines/reference/destructureGenerics.types b/tests/baselines/reference/destructureGenerics.types new file mode 100644 index 0000000000000..f0d579113eef4 --- /dev/null +++ b/tests/baselines/reference/destructureGenerics.types @@ -0,0 +1,53 @@ +=== tests/cases/compiler/destructureGenerics.ts === +declare function f(...args: T): T; +>f : (...args: T) => T +>T : T +>args : T +>T : T +>T : T + +var x = f(1,2); +>x : [1, 2] +>f(1,2) : [1, 2] +>f : (...args: T) => T +>1 : 1 +>2 : 2 + +var x: [1, 2]; +>x : [1, 2] + +declare function g(...args: T): T; +>g : (...args: T) => T +>T : T +>args : T +>T : T +>T : T + +var z = g(1,2); +>z : [1, 2] +>g(1,2) : [1, 2] +>g : (...args: T) => T +>1 : 1 +>2 : 2 + +var z: [1,2]; +>z : [1, 2] + +declare function h(...args: T[]): T; +>h : (...args: T[]) => T +>T : T +>args : T[] +>T : T +>T : T + +var b = h(1,2,3); +>b : number +>h(1,2,3) : 1 | 2 | 3 +>h : (...args: T[]) => T +>1 : 1 +>2 : 2 +>3 : 3 + +var b: number; +>b : number + diff --git a/tests/baselines/reference/destructureGenericsErrors.errors.txt b/tests/baselines/reference/destructureGenericsErrors.errors.txt new file mode 100644 index 0000000000000..d99bd4f00be6a --- /dev/null +++ b/tests/baselines/reference/destructureGenericsErrors.errors.txt @@ -0,0 +1,26 @@ +tests/cases/compiler/destructureGenericsErrors.ts(2,9): error TS2554: Expected 2 arguments, but got 1. +tests/cases/compiler/destructureGenericsErrors.ts(3,9): error TS2554: Expected 2 arguments, but got 3. +tests/cases/compiler/destructureGenericsErrors.ts(4,48): error TS2563: A rest parameter in a function with optional parameters must be of an array type. +tests/cases/compiler/destructureGenericsErrors.ts(4,55): error TS1047: A rest parameter cannot be optional. +tests/cases/compiler/destructureGenericsErrors.ts(6,60): error TS2563: A rest parameter in a function with optional parameters must be of an array type. + + +==== tests/cases/compiler/destructureGenericsErrors.ts (5 errors) ==== + declare function g(...args: T): T; + var y = g(1); // error + ~~~~ +!!! error TS2554: Expected 2 arguments, but got 1. + var a = g(1,2,3); // error + ~~~~~~~~ +!!! error TS2554: Expected 2 arguments, but got 3. + declare function k(...args?: T): T; + ~~~~~~~~~~~ +!!! error TS2563: A rest parameter in a function with optional parameters must be of an array type. + ~ +!!! error TS1047: A rest parameter cannot be optional. + var u = k(1,2); // error + declare function m(a?: string, ...args: T): T; + ~~~~~~~~~~ +!!! error TS2563: A rest parameter in a function with optional parameters must be of an array type. + var v = m('a',1,2); // error + \ No newline at end of file diff --git a/tests/baselines/reference/destructureGenericsErrors.js b/tests/baselines/reference/destructureGenericsErrors.js new file mode 100644 index 0000000000000..e84d066e93b02 --- /dev/null +++ b/tests/baselines/reference/destructureGenericsErrors.js @@ -0,0 +1,15 @@ +//// [destructureGenericsErrors.ts] +declare function g(...args: T): T; +var y = g(1); // error +var a = g(1,2,3); // error +declare function k(...args?: T): T; +var u = k(1,2); // error +declare function m(a?: string, ...args: T): T; +var v = m('a',1,2); // error + + +//// [destructureGenericsErrors.js] +var y = g(1); // error +var a = g(1, 2, 3); // error +var u = k(1, 2); // error +var v = m('a', 1, 2); // error diff --git a/tests/baselines/reference/destructureGenericsErrors.symbols b/tests/baselines/reference/destructureGenericsErrors.symbols new file mode 100644 index 0000000000000..439835a05bc1c --- /dev/null +++ b/tests/baselines/reference/destructureGenericsErrors.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/destructureGenericsErrors.ts === +declare function g(...args: T): T; +>g : Symbol(g, Decl(destructureGenericsErrors.ts, 0, 0)) +>T : Symbol(T, Decl(destructureGenericsErrors.ts, 0, 19)) +>args : Symbol(args, Decl(destructureGenericsErrors.ts, 0, 47)) +>T : Symbol(T, Decl(destructureGenericsErrors.ts, 0, 19)) +>T : Symbol(T, Decl(destructureGenericsErrors.ts, 0, 19)) + +// var y = g(1); // error +// var y: [1]; +var a = g(1,2,3); // error +>a : Symbol(a, Decl(destructureGenericsErrors.ts, 3, 3), Decl(destructureGenericsErrors.ts, 4, 3)) +>g : Symbol(g, Decl(destructureGenericsErrors.ts, 0, 0)) + +var a: [1,2,3]; +>a : Symbol(a, Decl(destructureGenericsErrors.ts, 3, 3), Decl(destructureGenericsErrors.ts, 4, 3)) + diff --git a/tests/baselines/reference/destructureGenericsErrors.types b/tests/baselines/reference/destructureGenericsErrors.types new file mode 100644 index 0000000000000..df45f2496d165 --- /dev/null +++ b/tests/baselines/reference/destructureGenericsErrors.types @@ -0,0 +1,21 @@ +=== tests/cases/compiler/destructureGenericsErrors.ts === +declare function g(...args: T): T; +>g : (...args: T) => T +>T : T +>args : T +>T : T +>T : T + +// var y = g(1); // error +// var y: [1]; +var a = g(1,2,3); // error +>a : [1, 2, 3] +>g(1,2,3) : [1, 2, 3] +>g : (...args: T) => T +>1 : 1 +>2 : 2 +>3 : 3 + +var a: [1,2,3]; +>a : [1, 2, 3] + diff --git a/tests/baselines/reference/destructuringParameterDeclaration4.errors.txt b/tests/baselines/reference/destructuringParameterDeclaration4.errors.txt index cdc7938d1af64..bd201494d5934 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration4.errors.txt +++ b/tests/baselines/reference/destructuringParameterDeclaration4.errors.txt @@ -1,5 +1,3 @@ -tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts(11,13): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts(13,13): error TS2370: A rest parameter must be of an array type. tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts(14,17): error TS1047: A rest parameter cannot be optional. tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts(15,16): error TS1048: A rest parameter cannot have an initializer. tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts(20,19): error TS2345: Argument of type 'true' is not assignable to parameter of type 'string | number'. @@ -17,7 +15,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts( tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts(34,28): error TS2304: Cannot find name 'E'. -==== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts (12 errors) ==== +==== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts (10 errors) ==== // If the parameter is a rest parameter, the parameter type is any[] // A type annotation for a rest parameter must denote an array type. @@ -29,12 +27,8 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts( type stringOrNumArray = Array; function a0(...x: [number, number, string]) { } // Error, rest parameter must be array type - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. function a1(...x: (number|string)[]) { } function a2(...a: someArray) { } // Error, rest parameter must be array type - ~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. function a3(...b?) { } // Error, can't be optional ~ !!! error TS1047: A rest parameter cannot be optional. diff --git a/tests/baselines/reference/iterableArrayPattern25.errors.txt b/tests/baselines/reference/iterableArrayPattern25.errors.txt index 07f46c0d49ee8..19f2dca07f392 100644 --- a/tests/baselines/reference/iterableArrayPattern25.errors.txt +++ b/tests/baselines/reference/iterableArrayPattern25.errors.txt @@ -1,8 +1,11 @@ tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts(1,33): error TS2501: A rest element cannot contain a binding pattern. +tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts(2,1): error TS2554: Expected 2 arguments, but got 1. -==== tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts (1 errors) ==== +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts (2 errors) ==== function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { } ~~~~~~~~~~~~~~~~~~~~ !!! error TS2501: A rest element cannot contain a binding pattern. - takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); \ No newline at end of file + takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2554: Expected 2 arguments, but got 1. \ No newline at end of file diff --git a/tests/baselines/reference/noImplicitAnyDestructuringParameterDeclaration.errors.txt b/tests/baselines/reference/noImplicitAnyDestructuringParameterDeclaration.errors.txt index a15f9c07cd3e7..ba5f00b74e29e 100644 --- a/tests/baselines/reference/noImplicitAnyDestructuringParameterDeclaration.errors.txt +++ b/tests/baselines/reference/noImplicitAnyDestructuringParameterDeclaration.errors.txt @@ -2,19 +2,22 @@ tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(1,14): er tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(1,19): error TS7031: Binding element 'b' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(1,23): error TS7006: Parameter 'c' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(1,26): error TS7006: Parameter 'd' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(3,13): error TS7006: Parameter '[a = undefined]' implicitly has an '[any]' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(3,14): error TS7031: Binding element 'a' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(3,31): error TS7031: Binding element 'b' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(3,42): error TS7006: Parameter 'c' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(3,57): error TS7006: Parameter 'd' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(7,20): error TS7008: Member 'b' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(7,30): error TS7008: Member 'b' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(9,13): error TS7006: Parameter '[a1]' implicitly has an '[any]' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(9,14): error TS7031: Binding element 'a1' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(9,34): error TS7031: Binding element 'b1' implicitly has an 'any' type. +tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(9,42): error TS7018: Object literal's property 'b1' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(9,54): error TS7006: Parameter 'c1' implicitly has an 'any' type. tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(9,70): error TS7006: Parameter 'd1' implicitly has an 'any' type. -==== tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts (14 errors) ==== +==== tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts (17 errors) ==== function f1([a], {b}, c, d) { // error ~ !!! error TS7031: Binding element 'a' implicitly has an 'any' type. @@ -26,6 +29,8 @@ tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(9,70): er !!! error TS7006: Parameter 'd' implicitly has an 'any' type. } function f2([a = undefined], {b = null}, c = undefined, d = null) { // error + ~~~~~~~~~~~~~~~ +!!! error TS7006: Parameter '[a = undefined]' implicitly has an '[any]' type. ~ !!! error TS7031: Binding element 'a' implicitly has an 'any' type. ~ @@ -44,10 +49,14 @@ tests/cases/compiler/noImplicitAnyDestructuringParameterDeclaration.ts(9,70): er !!! error TS7008: Member 'b' implicitly has an 'any' type. } function f5([a1] = [undefined], {b1} = { b1: null }, c1 = undefined, d1 = null) { // error + ~~~~~~~~~~~~~~~~~~ +!!! error TS7006: Parameter '[a1]' implicitly has an '[any]' type. ~~ !!! error TS7031: Binding element 'a1' implicitly has an 'any' type. ~~ !!! error TS7031: Binding element 'b1' implicitly has an 'any' type. + ~~~~~~~~ +!!! error TS7018: Object literal's property 'b1' implicitly has an 'any' type. ~~~~~~~~~~~~~~ !!! error TS7006: Parameter 'c1' implicitly has an 'any' type. ~~~~~~~~~ diff --git a/tests/baselines/reference/partiallyAnnotatedFunctionInferenceWithTypeParameter.types b/tests/baselines/reference/partiallyAnnotatedFunctionInferenceWithTypeParameter.types index c2113ae4d75d9..4de80c6f85a40 100644 --- a/tests/baselines/reference/partiallyAnnotatedFunctionInferenceWithTypeParameter.types +++ b/tests/baselines/reference/partiallyAnnotatedFunctionInferenceWithTypeParameter.types @@ -119,7 +119,7 @@ testRest((t1, t2: D, t3) => {}) >t3 : D testRest((t2: D, ...t3) => {}) ->testRest((t2: D, ...t3) => {}) : any +>testRest((t2: D, ...t3) => {}) : D >testRest : (a: (t: T, t1: T, ...ts: T[]) => void) => T >(t2: D, ...t3) => {} : (t2: D, ...t3: any[]) => void >t2 : D diff --git a/tests/baselines/reference/promiseSpread.js b/tests/baselines/reference/promiseSpread.js new file mode 100644 index 0000000000000..c770325bb5623 --- /dev/null +++ b/tests/baselines/reference/promiseSpread.js @@ -0,0 +1,8 @@ +//// [promiseSpread.ts] +interface Promise { + spread(fulfilledHandler: (...values: T & any[]) => U | Promise): Promise; + spread(fulfilledHandler: (...values: [T]) => U | Promise): Promise; +} + + +//// [promiseSpread.js] diff --git a/tests/baselines/reference/promiseSpread.symbols b/tests/baselines/reference/promiseSpread.symbols new file mode 100644 index 0000000000000..89fefa3f62d53 --- /dev/null +++ b/tests/baselines/reference/promiseSpread.symbols @@ -0,0 +1,30 @@ +=== tests/cases/compiler/promiseSpread.ts === +interface Promise { +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseSpread.ts, 0, 0)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseSpread.ts, 0, 18)) + + spread(fulfilledHandler: (...values: T & any[]) => U | Promise): Promise; +>spread : Symbol(Promise.spread, Decl(promiseSpread.ts, 0, 22), Decl(promiseSpread.ts, 1, 86)) +>U : Symbol(U, Decl(promiseSpread.ts, 1, 11)) +>fulfilledHandler : Symbol(fulfilledHandler, Decl(promiseSpread.ts, 1, 14)) +>values : Symbol(values, Decl(promiseSpread.ts, 1, 33)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseSpread.ts, 0, 18)) +>U : Symbol(U, Decl(promiseSpread.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseSpread.ts, 0, 0)) +>U : Symbol(U, Decl(promiseSpread.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseSpread.ts, 0, 0)) +>U : Symbol(U, Decl(promiseSpread.ts, 1, 11)) + + spread(fulfilledHandler: (...values: [T]) => U | Promise): Promise; +>spread : Symbol(Promise.spread, Decl(promiseSpread.ts, 0, 22), Decl(promiseSpread.ts, 1, 86)) +>U : Symbol(U, Decl(promiseSpread.ts, 2, 11)) +>fulfilledHandler : Symbol(fulfilledHandler, Decl(promiseSpread.ts, 2, 14)) +>values : Symbol(values, Decl(promiseSpread.ts, 2, 33)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseSpread.ts, 0, 18)) +>U : Symbol(U, Decl(promiseSpread.ts, 2, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseSpread.ts, 0, 0)) +>U : Symbol(U, Decl(promiseSpread.ts, 2, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseSpread.ts, 0, 0)) +>U : Symbol(U, Decl(promiseSpread.ts, 2, 11)) +} + diff --git a/tests/baselines/reference/promiseSpread.types b/tests/baselines/reference/promiseSpread.types new file mode 100644 index 0000000000000..a1ec04e34ac5c --- /dev/null +++ b/tests/baselines/reference/promiseSpread.types @@ -0,0 +1,30 @@ +=== tests/cases/compiler/promiseSpread.ts === +interface Promise { +>Promise : Promise +>T : T + + spread(fulfilledHandler: (...values: T & any[]) => U | Promise): Promise; +>spread : { (fulfilledHandler: (...values: T & any[]) => U | Promise): Promise; (fulfilledHandler: (...values: [T]) => U | Promise): Promise; } +>U : U +>fulfilledHandler : (...values: T & any[]) => U | Promise +>values : T & any[] +>T : T +>U : U +>Promise : Promise +>U : U +>Promise : Promise +>U : U + + spread(fulfilledHandler: (...values: [T]) => U | Promise): Promise; +>spread : { (fulfilledHandler: (...values: T & any[]) => U | Promise): Promise; (fulfilledHandler: (...values: [T]) => U | Promise): Promise; } +>U : U +>fulfilledHandler : (...values: [T]) => U | Promise +>values : [T] +>T : T +>U : U +>Promise : Promise +>U : U +>Promise : Promise +>U : U +} + diff --git a/tests/baselines/reference/restParamModifier.errors.txt b/tests/baselines/reference/restParamModifier.errors.txt index 87c73fcdc711f..4df0e1f6b4246 100644 --- a/tests/baselines/reference/restParamModifier.errors.txt +++ b/tests/baselines/reference/restParamModifier.errors.txt @@ -1,15 +1,12 @@ -tests/cases/compiler/restParamModifier.ts(2,17): error TS2370: A rest parameter must be of an array type. tests/cases/compiler/restParamModifier.ts(2,27): error TS1005: '=' expected. tests/cases/compiler/restParamModifier.ts(2,27): error TS2304: Cannot find name 'rest'. tests/cases/compiler/restParamModifier.ts(2,31): error TS1005: ',' expected. tests/cases/compiler/restParamModifier.ts(2,39): error TS1005: '=' expected. -==== tests/cases/compiler/restParamModifier.ts (5 errors) ==== +==== tests/cases/compiler/restParamModifier.ts (4 errors) ==== class C { constructor(...public rest: string[]) {} - ~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. ~~~~ !!! error TS1005: '=' expected. ~~~~ diff --git a/tests/baselines/reference/restParametersOfNonArrayTypes2.errors.txt b/tests/baselines/reference/restParametersOfNonArrayTypes2.errors.txt index 654f053e8bb62..5c31031cba4bc 100644 --- a/tests/baselines/reference/restParametersOfNonArrayTypes2.errors.txt +++ b/tests/baselines/reference/restParametersOfNonArrayTypes2.errors.txt @@ -1,40 +1,12 @@ -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(7,14): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(8,22): error TS2370: A rest parameter must be of an array type. tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(9,11): error TS1014: A rest parameter must be last in a parameter list. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(9,11): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(9,26): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(12,9): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(16,6): error TS2370: A rest parameter must be of an array type. tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(17,9): error TS1014: A rest parameter must be last in a parameter list. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(17,9): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(17,24): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(21,6): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(22,9): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(26,9): error TS2370: A rest parameter must be of an array type. tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(27,21): error TS1014: A rest parameter must be last in a parameter list. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(27,21): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(27,36): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(28,9): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(34,15): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(35,23): error TS2370: A rest parameter must be of an array type. tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(36,11): error TS1014: A rest parameter must be last in a parameter list. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(36,11): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(36,35): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(39,9): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(43,6): error TS2370: A rest parameter must be of an array type. tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(44,9): error TS1014: A rest parameter must be last in a parameter list. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(44,9): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(44,33): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(48,6): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(49,9): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(53,9): error TS2370: A rest parameter must be of an array type. tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(54,21): error TS1014: A rest parameter must be last in a parameter list. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(54,21): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(54,45): error TS2370: A rest parameter must be of an array type. -tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts(55,9): error TS2370: A rest parameter must be of an array type. -==== tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts (34 errors) ==== +==== tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfNonArrayTypes2.ts (6 errors) ==== // Rest parameters must be an array type if they have a type annotation, // user defined subtypes of array do not count, all of these are errors @@ -42,120 +14,64 @@ tests/cases/conformance/types/objectTypeLiteral/callSignatures/restParametersOfN interface MyThing2 extends Array { } function foo(...x: MyThing) { } - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. var f = function foo(...x: MyThing) { } - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. var f2 = (...x: MyThing, ...y: MyThing) => { } ~~~ !!! error TS1014: A rest parameter must be last in a parameter list. - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. class C { foo(...x: MyThing) { } - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. } interface I { (...x: MyThing); - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. foo(...x: MyThing, ...y: MyThing); ~~~ !!! error TS1014: A rest parameter must be last in a parameter list. - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. } var a: { (...x: MyThing); - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. foo(...x: MyThing); - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. } var b = { foo(...x: MyThing) { }, - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. a: function foo(...x: MyThing, ...y: MyThing) { }, ~~~ !!! error TS1014: A rest parameter must be last in a parameter list. - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. b: (...x: MyThing) => { } - ~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. } function foo2(...x: MyThing2) { } - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. var f3 = function foo(...x: MyThing2) { } - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. var f4 = (...x: MyThing2, ...y: MyThing2) => { } ~~~ !!! error TS1014: A rest parameter must be last in a parameter list. - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. class C2 { foo(...x: MyThing2) { } - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. } interface I2 { (...x: MyThing2); - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. foo(...x: MyThing2, ...y: MyThing2); ~~~ !!! error TS1014: A rest parameter must be last in a parameter list. - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. } var a2: { (...x: MyThing2); - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. foo(...x: MyThing2); - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. } var b2 = { foo(...x: MyThing2) { }, - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. a: function foo(...x: MyThing2, ...y: MyThing2) { }, ~~~ !!! error TS1014: A rest parameter must be last in a parameter list. - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. b: (...x: MyThing2) => { } - ~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2370: A rest parameter must be of an array type. } \ No newline at end of file diff --git a/tests/cases/compiler/destructureGenerics.ts b/tests/cases/compiler/destructureGenerics.ts new file mode 100644 index 0000000000000..0136279a4fb24 --- /dev/null +++ b/tests/cases/compiler/destructureGenerics.ts @@ -0,0 +1,9 @@ +declare function f(...args: T): T; +var x = f(1,2); +var x: [1, 2]; +declare function g(...args: T): T; +var z = g(1,2); +var z: [1,2]; +declare function h(...args: T[]): T; +var b = h(1,2,3); +var b: number; diff --git a/tests/cases/compiler/destructureGenericsErrors.ts b/tests/cases/compiler/destructureGenericsErrors.ts new file mode 100644 index 0000000000000..2cb9f203c4cbd --- /dev/null +++ b/tests/cases/compiler/destructureGenericsErrors.ts @@ -0,0 +1,7 @@ +declare function g(...args: T): T; +var y = g(1); // error +var a = g(1,2,3); // error +declare function k(...args?: T): T; +var u = k(1,2); // error +declare function m(a?: string, ...args: T): T; +var v = m('a',1,2); // error diff --git a/tests/cases/compiler/promiseSpread.ts b/tests/cases/compiler/promiseSpread.ts new file mode 100644 index 0000000000000..6ea288064c32a --- /dev/null +++ b/tests/cases/compiler/promiseSpread.ts @@ -0,0 +1,4 @@ +interface Promise { + spread(fulfilledHandler: (...values: T & any[]) => U | Promise): Promise; + spread(fulfilledHandler: (...values: [T]) => U | Promise): Promise; +}