diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 178a8d79880a1..ea38a8f4b31b8 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2078,15 +2078,20 @@ module ts { } } else { - // For an array binding element the specified or inferred type of the parent must be an array-like type - if (!isArrayLikeType(parentType)) { - error(pattern, Diagnostics.Type_0_is_not_an_array_type, typeToString(parentType)); - return unknownType; - } + // This elementType will be used if the specific property corresponding to this index is not + // present (aka the tuple element property). This call also checks that the parentType is in + // fact an iterable or array (depending on target language). + let elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false); if (!declaration.dotDotDotToken) { + if (elementType.flags & TypeFlags.Any) { + return elementType; + } + // Use specific property type when parent is a tuple or numeric index type when parent is an array let propName = "" + indexOf(pattern.elements, declaration); - type = isTupleLikeType(parentType) ? getTypeOfPropertyOfType(parentType, propName) : getIndexTypeOfType(parentType, IndexKind.Number); + type = isTupleLikeType(parentType) + ? getTypeOfPropertyOfType(parentType, propName) + : elementType; if (!type) { if (isTupleType(parentType)) { error(declaration, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), (parentType).elementTypes.length, pattern.elements.length); @@ -2099,7 +2104,7 @@ module ts { } else { // Rest element has an array type with the same element type as the parent type - type = createArrayType(getIndexTypeOfType(parentType, IndexKind.Number)); + type = createArrayType(elementType); } } return type; @@ -2188,7 +2193,34 @@ module ts { hasSpreadElement = true; } }); - return !elementTypes.length ? anyArrayType : hasSpreadElement ? createArrayType(getUnionType(elementTypes)) : createTupleType(elementTypes); + if (!elementTypes.length) { + return languageVersion >= ScriptTarget.ES6 ? createIterableType(anyType) : anyArrayType; + } + else if (hasSpreadElement) { + let unionOfElements = getUnionType(elementTypes); + if (languageVersion >= ScriptTarget.ES6) { + // If the user has something like: + // + // function fun(...[a, ...b]) { } + // + // Normally, in ES6, the implied type of an array binding pattern with a rest element is + // an iterable. However, there is a requirement in our type system that all rest + // parameters be array types. To satisfy this, we have an exception to the rule that + // says the type of an array binding pattern with a rest element is an array type + // if it is *itself* in a rest parameter. It will still be compatible with a spreaded + // iterable argument, but within the function it will be an array. + let parent = pattern.parent; + let isRestParameter = parent.kind === SyntaxKind.Parameter && + pattern === (parent).name && + (parent).dotDotDotToken !== undefined; + return isRestParameter ? createArrayType(unionOfElements) : createIterableType(unionOfElements); + } + + return createArrayType(unionOfElements); + } + + // If the pattern has at least one element, and no rest element, then it should imply a tuple type. + return createTupleType(elementTypes); } // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself @@ -3461,6 +3493,10 @@ module ts { return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol")); } + function createIterableType(elementType: Type): Type { + return globalIterableType !== emptyObjectType ? createTypeReference(globalIterableType, [elementType]) : emptyObjectType; + } + function createArrayType(elementType: Type): Type { // globalArrayType will be undefined if we get here during creation of the Array type. This for example happens if // user code augments the Array type with call or construct signatures that have an array type as the return type. @@ -5968,12 +6004,14 @@ module ts { } function checkSpreadElementExpression(node: SpreadElementExpression, contextualMapper?: TypeMapper): Type { - let type = checkExpressionCached(node.expression, contextualMapper); - if (!isArrayLikeType(type)) { - error(node.expression, Diagnostics.Type_0_is_not_an_array_type, typeToString(type)); - return unknownType; - } - return type; + // It is usually not safe to call checkExpressionCached if we can be contextually typing. + // You can tell that we are contextually typing because of the contextualMapper parameter. + // While it is true that a spread element can have a contextual type, it does not do anything + // with this type. It is neither affected by it, nor does it propagate it to its operand. + // So the fact that contextualMapper is passed is not important, because the operand of a spread + // element is not contextually typed. + let arrayOrIterableType = checkExpressionCached(node.expression, contextualMapper); + return checkIteratedTypeOrElementType(arrayOrIterableType, node.expression, /*allowStringInput*/ false); } function checkArrayLiteral(node: ArrayLiteralExpression, contextualMapper?: TypeMapper): Type { @@ -5981,18 +6019,13 @@ module ts { if (!elements.length) { return createArrayType(undefinedType); } - let hasSpreadElement: boolean = false; + let hasSpreadElement = false; let elementTypes: Type[] = []; - forEach(elements, e => { + for (let e of elements) { let type = checkExpression(e, contextualMapper); - if (e.kind === SyntaxKind.SpreadElementExpression) { - elementTypes.push(getIndexTypeOfType(type, IndexKind.Number) || anyType); - hasSpreadElement = true; - } - else { - elementTypes.push(type); - } - }); + elementTypes.push(type); + hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElementExpression; + } if (!hasSpreadElement) { let contextualType = getContextualType(node); if (contextualType && contextualTypeIsTupleLikeType(contextualType) || isAssignmentTarget(node)) { @@ -6615,7 +6648,7 @@ module ts { for (let i = 0; i < args.length; i++) { let arg = args[i]; if (arg.kind !== SyntaxKind.OmittedExpression) { - let paramType = getTypeAtPosition(signature, arg.kind === SyntaxKind.SpreadElementExpression ? -1 : i); + let paramType = getTypeAtPosition(signature, i); let argType: Type; if (i === 0 && args[i].parent.kind === SyntaxKind.TaggedTemplateExpression) { argType = globalTemplateStringsArrayType; @@ -6638,7 +6671,7 @@ module ts { // No need to check for omitted args and template expressions, their exlusion value is always undefined if (excludeArgument[i] === false) { let arg = args[i]; - let paramType = getTypeAtPosition(signature, arg.kind === SyntaxKind.SpreadElementExpression ? -1 : i); + let paramType = getTypeAtPosition(signature, i); inferTypes(context, checkExpressionWithContextualType(arg, paramType, inferenceMapper), paramType); } } @@ -6671,7 +6704,7 @@ module ts { let arg = args[i]; if (arg.kind !== SyntaxKind.OmittedExpression) { // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter) - let paramType = getTypeAtPosition(signature, arg.kind === SyntaxKind.SpreadElementExpression ? -1 : i); + let paramType = getTypeAtPosition(signature, i); // A tagged template expression provides a special first argument, and string literals get string literal types // unless we're reporting errors let argType = i === 0 && node.kind === SyntaxKind.TaggedTemplateExpression ? globalTemplateStringsArrayType : @@ -7145,14 +7178,9 @@ module ts { } function getTypeAtPosition(signature: Signature, pos: number): Type { - if (pos >= 0) { - return signature.hasRestParameter ? - pos < signature.parameters.length - 1 ? getTypeOfSymbol(signature.parameters[pos]) : getRestTypeOfSignature(signature) : - pos < signature.parameters.length ? getTypeOfSymbol(signature.parameters[pos]) : anyType; - } return signature.hasRestParameter ? - getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]) : - anyArrayType; + pos < signature.parameters.length - 1 ? getTypeOfSymbol(signature.parameters[pos]) : getRestTypeOfSignature(signature) : + pos < signature.parameters.length ? getTypeOfSymbol(signature.parameters[pos]) : anyType; } function assignContextualParameterTypes(signature: Signature, context: Signature, mapper: TypeMapper) { @@ -7588,11 +7616,10 @@ module ts { } function checkArrayLiteralAssignment(node: ArrayLiteralExpression, sourceType: Type, contextualMapper?: TypeMapper): Type { - // TODOO(andersh): Allow iterable source type in ES6 - if (!isArrayLikeType(sourceType)) { - error(node, Diagnostics.Type_0_is_not_an_array_type, typeToString(sourceType)); - return sourceType; - } + // This elementType will be used if the specific property corresponding to this index is not + // present (aka the tuple element property). This call also checks that the parentType is in + // fact an iterable or array (depending on target language). + let elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false); let elements = node.elements; for (let i = 0; i < elements.length; i++) { let e = elements[i]; @@ -7600,8 +7627,9 @@ module ts { if (e.kind !== SyntaxKind.SpreadElementExpression) { let propName = "" + i; let type = sourceType.flags & TypeFlags.Any ? sourceType : - isTupleLikeType(sourceType) ? getTypeOfPropertyOfType(sourceType, propName) : - getIndexTypeOfType(sourceType, IndexKind.Number); + isTupleLikeType(sourceType) + ? getTypeOfPropertyOfType(sourceType, propName) + : elementType; if (type) { checkDestructuringAssignment(e, type, contextualMapper); } @@ -7616,7 +7644,7 @@ module ts { } else { if (i === elements.length - 1) { - checkReferenceAssignment((e).expression, sourceType, contextualMapper); + checkReferenceAssignment((e).expression, createArrayType(elementType), contextualMapper); } else { error(e, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern); @@ -9373,29 +9401,41 @@ module ts { function checkRightHandSideOfForOf(rhsExpression: Expression): Type { let expressionType = getTypeOfExpression(rhsExpression); - return languageVersion >= ScriptTarget.ES6 - ? checkIteratedType(expressionType, rhsExpression) - : checkElementTypeOfArrayOrString(expressionType, rhsExpression); + return checkIteratedTypeOrElementType(expressionType, rhsExpression, /*allowStringInput*/ true); + } + + function checkIteratedTypeOrElementType(inputType: Type, errorNode: Node, allowStringInput: boolean): Type { + if (languageVersion >= ScriptTarget.ES6) { + return checkIteratedType(inputType, errorNode) || anyType; + } + + if (allowStringInput) { + return checkElementTypeOfArrayOrString(inputType, errorNode); + } + + if (isArrayLikeType(inputType)) { + return getIndexTypeOfType(inputType, IndexKind.Number); + } + + error(errorNode, Diagnostics.Type_0_is_not_an_array_type, typeToString(inputType)); + return unknownType; } /** - * When expressionForError is undefined, it means we should not report any errors. + * When errorNode is undefined, it means we should not report any errors. */ - function checkIteratedType(iterable: Type, expressionForError: Expression): Type { + function checkIteratedType(iterable: Type, errorNode: Node): Type { Debug.assert(languageVersion >= ScriptTarget.ES6); - let iteratedType = getIteratedType(iterable, expressionForError); + let iteratedType = getIteratedType(iterable, errorNode); // Now even though we have extracted the iteratedType, we will have to validate that the type // passed in is actually an Iterable. - if (expressionForError && iteratedType) { - let completeIterableType = globalIterableType !== emptyObjectType - ? createTypeReference(globalIterableType, [iteratedType]) - : emptyObjectType; - checkTypeAssignableTo(iterable, completeIterableType, expressionForError); + if (errorNode && iteratedType) { + checkTypeAssignableTo(iterable, createIterableType(iteratedType), errorNode); } return iteratedType; - function getIteratedType(iterable: Type, expressionForError: Expression) { + function getIteratedType(iterable: Type, errorNode: Node) { // We want to treat type as an iterable, and get the type it is an iterable of. The iterable // must have the following structure (annotated with the names of the variables below): // @@ -9426,6 +9466,12 @@ module ts { return undefined; } + // As an optimization, if the type is instantiated directly using the globalIterableType (Iterable), + // then just grab its type argument. + if ((iterable.flags & TypeFlags.Reference) && (iterable).target === globalIterableType) { + return (iterable).typeArguments[0]; + } + let iteratorFunction = getTypeOfPropertyOfType(iterable, getPropertyNameForKnownSymbolName("iterator")); if (iteratorFunction && allConstituentTypesHaveKind(iteratorFunction, TypeFlags.Any)) { return undefined; @@ -9433,8 +9479,8 @@ module ts { let iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, SignatureKind.Call) : emptyArray; if (iteratorFunctionSignatures.length === 0) { - if (expressionForError) { - error(expressionForError, Diagnostics.The_right_hand_side_of_a_for_of_statement_must_have_a_Symbol_iterator_method_that_returns_an_iterator); + if (errorNode) { + error(errorNode, Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator); } return undefined; } @@ -9451,8 +9497,8 @@ module ts { let iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, SignatureKind.Call) : emptyArray; if (iteratorNextFunctionSignatures.length === 0) { - if (expressionForError) { - error(expressionForError, Diagnostics.The_iterator_returned_by_the_right_hand_side_of_a_for_of_statement_must_have_a_next_method); + if (errorNode) { + error(errorNode, Diagnostics.An_iterator_must_have_a_next_method); } return undefined; } @@ -9464,8 +9510,8 @@ module ts { let iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value"); if (!iteratorNextValue) { - if (expressionForError) { - error(expressionForError, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property); + if (errorNode) { + error(errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property); } return undefined; } @@ -9491,7 +9537,7 @@ module ts { * 1. Some constituent is neither a string nor an array. * 2. Some constituent is a string and target is less than ES5 (because in ES3 string is not indexable). */ - function checkElementTypeOfArrayOrString(arrayOrStringType: Type, expressionForError: Expression): Type { + function checkElementTypeOfArrayOrString(arrayOrStringType: Type, errorNode: Node): Type { Debug.assert(languageVersion < ScriptTarget.ES6); // After we remove all types that are StringLike, we will know if there was a string constituent @@ -9502,7 +9548,7 @@ module ts { let reportedError = false; if (hasStringConstituent) { if (languageVersion < ScriptTarget.ES5) { - error(expressionForError, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher); + error(errorNode, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher); reportedError = true; } @@ -9522,7 +9568,7 @@ module ts { let diagnostic = hasStringConstituent ? Diagnostics.Type_0_is_not_an_array_type : Diagnostics.Type_0_is_not_an_array_type_or_a_string_type; - error(expressionForError, diagnostic, typeToString(arrayType)); + error(errorNode, diagnostic, typeToString(arrayType)); } return hasStringConstituent ? stringType : unknownType; } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index b4380f4d2deaf..5062be5ed46c2 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -344,8 +344,8 @@ module ts { The_left_hand_side_of_a_for_of_statement_cannot_be_a_previously_defined_constant: { code: 2485, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...of' statement cannot be a previously defined constant." }, The_left_hand_side_of_a_for_in_statement_cannot_be_a_previously_defined_constant: { code: 2486, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a previously defined constant." }, Invalid_left_hand_side_in_for_of_statement: { code: 2487, category: DiagnosticCategory.Error, key: "Invalid left-hand side in 'for...of' statement." }, - The_right_hand_side_of_a_for_of_statement_must_have_a_Symbol_iterator_method_that_returns_an_iterator: { code: 2488, category: DiagnosticCategory.Error, key: "The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator." }, - The_iterator_returned_by_the_right_hand_side_of_a_for_of_statement_must_have_a_next_method: { code: 2489, category: DiagnosticCategory.Error, key: "The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method." }, + Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator: { code: 2488, category: DiagnosticCategory.Error, key: "Type must have a '[Symbol.iterator]()' method that returns an iterator." }, + An_iterator_must_have_a_next_method: { code: 2489, category: DiagnosticCategory.Error, key: "An iterator must have a 'next()' method." }, The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property: { code: 2490, category: DiagnosticCategory.Error, key: "The type returned by the 'next()' method of an iterator must have a 'value' property." }, The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: { code: 2491, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a destructuring pattern." }, Cannot_redeclare_identifier_0_in_catch_clause: { code: 2492, category: DiagnosticCategory.Error, key: "Cannot redeclare identifier '{0}' in catch clause" }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index fe349b783439b..4476b0cad4a5a 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1367,11 +1367,11 @@ "category": "Error", "code": 2487 }, - "The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator.": { + "Type must have a '[Symbol.iterator]()' method that returns an iterator.": { "category": "Error", "code": 2488 }, - "The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method.": { + "An iterator must have a 'next()' method.": { "category": "Error", "code": 2489 }, diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts index a83c04e6e86b9..4c50e0e0cad99 100644 --- a/src/harness/typeWriter.ts +++ b/src/harness/typeWriter.ts @@ -52,6 +52,7 @@ class TypeWriterWalker { case ts.SyntaxKind.PostfixUnaryExpression: case ts.SyntaxKind.BinaryExpression: case ts.SyntaxKind.ConditionalExpression: + case ts.SyntaxKind.SpreadElementExpression: this.log(node, this.getTypeOfNode(node)); break; diff --git a/tests/baselines/reference/ES5For-of30.errors.txt b/tests/baselines/reference/ES5For-of30.errors.txt index 0b02a55ba3f56..e99b8284bf336 100644 --- a/tests/baselines/reference/ES5For-of30.errors.txt +++ b/tests/baselines/reference/ES5For-of30.errors.txt @@ -1,12 +1,18 @@ tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,6): error TS2461: Type 'string | number' is not an array type. +tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,7): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,14): error TS2322: Type 'string' is not assignable to type 'number'. -==== tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts (1 errors) ==== +==== tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts (3 errors) ==== var a: string, b: number; var tuple: [number, string] = [2, "3"]; for ([a = 1, b = ""] of tuple) { ~~~~~~~~~~~~~~~ !!! error TS2461: Type 'string | number' is not an array type. + ~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. a; b; } \ No newline at end of file diff --git a/tests/baselines/reference/arrayLiteralSpread.types b/tests/baselines/reference/arrayLiteralSpread.types index 0dae59521bf6c..73d4f6013ed4c 100644 --- a/tests/baselines/reference/arrayLiteralSpread.types +++ b/tests/baselines/reference/arrayLiteralSpread.types @@ -9,44 +9,55 @@ function f0() { var a1 = [...a]; >a1 : number[] >[...a] : number[] +>...a : number >a : number[] var a2 = [1, ...a]; >a2 : number[] >[1, ...a] : number[] +>...a : number >a : number[] var a3 = [1, 2, ...a]; >a3 : number[] >[1, 2, ...a] : number[] +>...a : number >a : number[] var a4 = [...a, 1]; >a4 : number[] >[...a, 1] : number[] +>...a : number >a : number[] var a5 = [...a, 1, 2]; >a5 : number[] >[...a, 1, 2] : number[] +>...a : number >a : number[] var a6 = [1, 2, ...a, 1, 2]; >a6 : number[] >[1, 2, ...a, 1, 2] : number[] +>...a : number >a : number[] var a7 = [1, ...a, 2, ...a]; >a7 : number[] >[1, ...a, 2, ...a] : number[] +>...a : number >a : number[] +>...a : number >a : number[] var a8 = [...a, ...a, ...a]; >a8 : number[] >[...a, ...a, ...a] : number[] +>...a : number >a : number[] +>...a : number >a : number[] +>...a : number >a : number[] } @@ -60,6 +71,7 @@ function f1() { var b = ["hello", ...a, true]; >b : (string | number | boolean)[] >["hello", ...a, true] : (string | number | boolean)[] +>...a : number >a : number[] var b: (string | number | boolean)[]; @@ -72,19 +84,29 @@ function f2() { var a = [...[...[...[...[...[]]]]]]; >a : any[] >[...[...[...[...[...[]]]]]] : undefined[] +>...[...[...[...[...[]]]]] : undefined >[...[...[...[...[]]]]] : undefined[] +>...[...[...[...[]]]] : undefined >[...[...[...[]]]] : undefined[] +>...[...[...[]]] : undefined >[...[...[]]] : undefined[] +>...[...[]] : undefined >[...[]] : undefined[] +>...[] : undefined >[] : undefined[] var b = [...[...[...[...[...[5]]]]]]; >b : number[] >[...[...[...[...[...[5]]]]]] : number[] +>...[...[...[...[...[5]]]]] : number >[...[...[...[...[5]]]]] : number[] +>...[...[...[...[5]]]] : number >[...[...[...[5]]]] : number[] +>...[...[...[5]]] : number >[...[...[5]]] : number[] +>...[...[5]] : number >[...[5]] : number[] +>...[5] : number >[5] : number[] } diff --git a/tests/baselines/reference/callWithSpreadES6.types b/tests/baselines/reference/callWithSpreadES6.types index 8a75d21e4efba..10dd611d2136f 100644 --- a/tests/baselines/reference/callWithSpreadES6.types +++ b/tests/baselines/reference/callWithSpreadES6.types @@ -38,11 +38,13 @@ foo(1, 2, "abc"); foo(1, 2, ...a); >foo(1, 2, ...a) : void >foo : (x: number, y: number, ...z: string[]) => void +>...a : string >a : string[] foo(1, 2, ...a, "abc"); >foo(1, 2, ...a, "abc") : void >foo : (x: number, y: number, ...z: string[]) => void +>...a : string >a : string[] obj.foo(1, 2, "abc"); @@ -56,6 +58,7 @@ obj.foo(1, 2, ...a); >obj.foo : (x: number, y: number, ...z: string[]) => any >obj : X >foo : (x: number, y: number, ...z: string[]) => any +>...a : string >a : string[] obj.foo(1, 2, ...a, "abc"); @@ -63,6 +66,7 @@ obj.foo(1, 2, ...a, "abc"); >obj.foo : (x: number, y: number, ...z: string[]) => any >obj : X >foo : (x: number, y: number, ...z: string[]) => any +>...a : string >a : string[] (obj.foo)(1, 2, "abc"); @@ -78,6 +82,7 @@ obj.foo(1, 2, ...a, "abc"); >obj.foo : (x: number, y: number, ...z: string[]) => any >obj : X >foo : (x: number, y: number, ...z: string[]) => any +>...a : string >a : string[] (obj.foo)(1, 2, ...a, "abc"); @@ -86,6 +91,7 @@ obj.foo(1, 2, ...a, "abc"); >obj.foo : (x: number, y: number, ...z: string[]) => any >obj : X >foo : (x: number, y: number, ...z: string[]) => any +>...a : string >a : string[] xa[1].foo(1, 2, "abc"); @@ -101,6 +107,7 @@ xa[1].foo(1, 2, ...a); >xa[1] : X >xa : X[] >foo : (x: number, y: number, ...z: string[]) => any +>...a : string >a : string[] xa[1].foo(1, 2, ...a, "abc"); @@ -109,6 +116,7 @@ xa[1].foo(1, 2, ...a, "abc"); >xa[1] : X >xa : X[] >foo : (x: number, y: number, ...z: string[]) => any +>...a : string >a : string[] (xa[1].foo)(...[1, 2, "abc"]); @@ -120,6 +128,7 @@ xa[1].foo(1, 2, ...a, "abc"); >xa[1] : X >xa : X[] >foo : (x: number, y: number, ...z: string[]) => any +>...[1, 2, "abc"] : string | number >[1, 2, "abc"] : (string | number)[] class C { @@ -145,6 +154,7 @@ class C { >foo : (x: number, y: number, ...z: string[]) => void >x : number >y : number +>...z : string >z : string[] } foo(x: number, y: number, ...z: string[]) { @@ -167,6 +177,7 @@ class D extends C { super(1, 2, ...a); >super(1, 2, ...a) : void >super : typeof C +>...a : string >a : string[] } foo() { @@ -183,6 +194,7 @@ class D extends C { >super.foo : (x: number, y: number, ...z: string[]) => void >super : C >foo : (x: number, y: number, ...z: string[]) => void +>...a : string >a : string[] } } @@ -192,5 +204,6 @@ var c = new C(1, 2, ...a); >c : C >new C(1, 2, ...a) : C >C : typeof C +>...a : string >a : string[] diff --git a/tests/baselines/reference/for-of14.errors.txt b/tests/baselines/reference/for-of14.errors.txt index 5e8223381c72c..ab95d0426891a 100644 --- a/tests/baselines/reference/for-of14.errors.txt +++ b/tests/baselines/reference/for-of14.errors.txt @@ -1,11 +1,11 @@ -tests/cases/conformance/es6/for-ofStatements/for-of14.ts(2,11): error TS2488: The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator. +tests/cases/conformance/es6/for-ofStatements/for-of14.ts(2,11): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. ==== tests/cases/conformance/es6/for-ofStatements/for-of14.ts (1 errors) ==== var v: string; for (v of new StringIterator) { } // Should fail because the iterator is not iterable ~~~~~~~~~~~~~~~~~~ -!!! error TS2488: The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator. +!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. class StringIterator { next() { diff --git a/tests/baselines/reference/for-of16.errors.txt b/tests/baselines/reference/for-of16.errors.txt index e3ecca1a25637..20e3e87653764 100644 --- a/tests/baselines/reference/for-of16.errors.txt +++ b/tests/baselines/reference/for-of16.errors.txt @@ -1,11 +1,11 @@ -tests/cases/conformance/es6/for-ofStatements/for-of16.ts(2,11): error TS2489: The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method. +tests/cases/conformance/es6/for-ofStatements/for-of16.ts(2,11): error TS2489: An iterator must have a 'next()' method. ==== tests/cases/conformance/es6/for-ofStatements/for-of16.ts (1 errors) ==== var v: string; for (v of new StringIterator) { } // Should fail ~~~~~~~~~~~~~~~~~~ -!!! error TS2489: The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method. +!!! error TS2489: An iterator must have a 'next()' method. class StringIterator { [Symbol.iterator]() { diff --git a/tests/baselines/reference/for-of57.js b/tests/baselines/reference/for-of57.js new file mode 100644 index 0000000000000..5a867c332f7cf --- /dev/null +++ b/tests/baselines/reference/for-of57.js @@ -0,0 +1,7 @@ +//// [for-of57.ts] +var iter: Iterable; +for (let num of iter) { } + +//// [for-of57.js] +var iter; +for (let num of iter) { } diff --git a/tests/baselines/reference/for-of57.types b/tests/baselines/reference/for-of57.types new file mode 100644 index 0000000000000..cfd4f68cfca2b --- /dev/null +++ b/tests/baselines/reference/for-of57.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/es6/for-ofStatements/for-of57.ts === +var iter: Iterable; +>iter : Iterable +>Iterable : Iterable + +for (let num of iter) { } +>num : number +>iter : Iterable + diff --git a/tests/baselines/reference/iterableArrayPattern1.js b/tests/baselines/reference/iterableArrayPattern1.js new file mode 100644 index 0000000000000..b45ac92d1fdc4 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern1.js @@ -0,0 +1,28 @@ +//// [iterableArrayPattern1.ts] +var [a, b] = new SymbolIterator; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern1.js] +var [a, b] = new SymbolIterator; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern1.types b/tests/baselines/reference/iterableArrayPattern1.types new file mode 100644 index 0000000000000..8be8521c6842e --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern1.types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern1.ts === +var [a, b] = new SymbolIterator; +>a : symbol +>b : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern10.errors.txt b/tests/baselines/reference/iterableArrayPattern10.errors.txt new file mode 100644 index 0000000000000..f06c4d7de17ea --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern10.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts(2,5): error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type '[any, any]'. + Property '0' is missing in type 'FooIterator'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts (1 errors) ==== + function fun([a, b]) { } + fun(new FooIterator); + ~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type '[any, any]'. +!!! error TS2345: Property '0' is missing in type 'FooIterator'. + class Bar { x } + class Foo extends Bar { y } + class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern10.js b/tests/baselines/reference/iterableArrayPattern10.js new file mode 100644 index 0000000000000..c8d37e3f8942e --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern10.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern10.ts] +function fun([a, b]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern10.js] +function fun([a, b]) { } +fun(new FooIterator); +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern11.js b/tests/baselines/reference/iterableArrayPattern11.js new file mode 100644 index 0000000000000..85ed4ab9710b1 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern11.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern11.ts] +function fun([a, b] = new FooIterator) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern11.js] +function fun([a, b] = new FooIterator) { } +fun(new FooIterator); +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern11.types b/tests/baselines/reference/iterableArrayPattern11.types new file mode 100644 index 0000000000000..2b6f1d6733640 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern11.types @@ -0,0 +1,52 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern11.ts === +function fun([a, b] = new FooIterator) { } +>fun : ([a, b]?: FooIterator) => void +>a : Foo +>b : Foo +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +fun(new FooIterator); +>fun(new FooIterator) : void +>fun : ([a, b]?: FooIterator) => void +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +class Bar { x } +>Bar : Bar +>x : any + +class Foo extends Bar { y } +>Foo : Foo +>Bar : Bar +>y : any + +class FooIterator { +>FooIterator : FooIterator + + next() { +>next : () => { value: Foo; done: boolean; } + + return { +>{ value: new Foo, done: false } : { value: Foo; done: boolean; } + + value: new Foo, +>value : Foo +>new Foo : Foo +>Foo : typeof Foo + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : FooIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern12.js b/tests/baselines/reference/iterableArrayPattern12.js new file mode 100644 index 0000000000000..4856af9cb48b6 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern12.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern12.ts] +function fun([a, ...b] = new FooIterator) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern12.js] +function fun([a, ...b] = new FooIterator) { } +fun(new FooIterator); +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern12.types b/tests/baselines/reference/iterableArrayPattern12.types new file mode 100644 index 0000000000000..a415539b91c83 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern12.types @@ -0,0 +1,52 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern12.ts === +function fun([a, ...b] = new FooIterator) { } +>fun : ([a, ...b]?: FooIterator) => void +>a : Foo +>b : Foo[] +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +fun(new FooIterator); +>fun(new FooIterator) : void +>fun : ([a, ...b]?: FooIterator) => void +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +class Bar { x } +>Bar : Bar +>x : any + +class Foo extends Bar { y } +>Foo : Foo +>Bar : Bar +>y : any + +class FooIterator { +>FooIterator : FooIterator + + next() { +>next : () => { value: Foo; done: boolean; } + + return { +>{ value: new Foo, done: false } : { value: Foo; done: boolean; } + + value: new Foo, +>value : Foo +>new Foo : Foo +>Foo : typeof Foo + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : FooIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern13.js b/tests/baselines/reference/iterableArrayPattern13.js new file mode 100644 index 0000000000000..06f9901a8517d --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern13.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern13.ts] +function fun([a, ...b]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern13.js] +function fun([a, ...b]) { } +fun(new FooIterator); +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern13.types b/tests/baselines/reference/iterableArrayPattern13.types new file mode 100644 index 0000000000000..dbfbf9a1ebcb6 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern13.types @@ -0,0 +1,50 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern13.ts === +function fun([a, ...b]) { } +>fun : ([a, ...b]: Iterable) => void +>a : any +>b : any[] + +fun(new FooIterator); +>fun(new FooIterator) : void +>fun : ([a, ...b]: Iterable) => void +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +class Bar { x } +>Bar : Bar +>x : any + +class Foo extends Bar { y } +>Foo : Foo +>Bar : Bar +>y : any + +class FooIterator { +>FooIterator : FooIterator + + next() { +>next : () => { value: Foo; done: boolean; } + + return { +>{ value: new Foo, done: false } : { value: Foo; done: boolean; } + + value: new Foo, +>value : Foo +>new Foo : Foo +>Foo : typeof Foo + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : FooIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern14.js b/tests/baselines/reference/iterableArrayPattern14.js new file mode 100644 index 0000000000000..a3595b0df0c48 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern14.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern14.ts] +function fun(...[a, ...b]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern14.js] +function fun(...[a, ...b]) { } +fun(new FooIterator); +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern14.types b/tests/baselines/reference/iterableArrayPattern14.types new file mode 100644 index 0000000000000..3f73f2973d10e --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern14.types @@ -0,0 +1,50 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern14.ts === +function fun(...[a, ...b]) { } +>fun : (...[a, ...b]: any[]) => void +>a : any +>b : any[] + +fun(new FooIterator); +>fun(new FooIterator) : void +>fun : (...[a, ...b]: any[]) => void +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +class Bar { x } +>Bar : Bar +>x : any + +class Foo extends Bar { y } +>Foo : Foo +>Bar : Bar +>y : any + +class FooIterator { +>FooIterator : FooIterator + + next() { +>next : () => { value: Foo; done: boolean; } + + return { +>{ value: new Foo, done: false } : { value: Foo; done: boolean; } + + value: new Foo, +>value : Foo +>new Foo : Foo +>Foo : typeof Foo + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : FooIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern15.js b/tests/baselines/reference/iterableArrayPattern15.js new file mode 100644 index 0000000000000..1c2050129ce2f --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern15.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern15.ts] +function fun(...[a, b]: Bar[]) { } +fun(...new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern15.js] +function fun(...[a, b]) { } +fun(...new FooIterator); +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern15.types b/tests/baselines/reference/iterableArrayPattern15.types new file mode 100644 index 0000000000000..de548a91c26ef --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern15.types @@ -0,0 +1,52 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern15.ts === +function fun(...[a, b]: Bar[]) { } +>fun : (...[a, b]: Bar[]) => void +>a : Bar +>b : Bar +>Bar : Bar + +fun(...new FooIterator); +>fun(...new FooIterator) : void +>fun : (...[a, b]: Bar[]) => void +>...new FooIterator : Foo +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +class Bar { x } +>Bar : Bar +>x : any + +class Foo extends Bar { y } +>Foo : Foo +>Bar : Bar +>y : any + +class FooIterator { +>FooIterator : FooIterator + + next() { +>next : () => { value: Foo; done: boolean; } + + return { +>{ value: new Foo, done: false } : { value: Foo; done: boolean; } + + value: new Foo, +>value : Foo +>new Foo : Foo +>Foo : typeof Foo + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : FooIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern16.errors.txt b/tests/baselines/reference/iterableArrayPattern16.errors.txt new file mode 100644 index 0000000000000..42236140be78a --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern16.errors.txt @@ -0,0 +1,37 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts(2,5): error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type '[Bar, Bar]'. + Property '0' is missing in type 'FooIterator'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts (1 errors) ==== + function fun(...[a, b]: [Bar, Bar][]) { } + fun(...new FooIteratorIterator); + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type '[Bar, Bar]'. +!!! error TS2345: Property '0' is missing in type 'FooIterator'. + class Bar { x } + class Foo extends Bar { y } + class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } + + class FooIteratorIterator { + next() { + return { + value: new FooIterator, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern16.js b/tests/baselines/reference/iterableArrayPattern16.js new file mode 100644 index 0000000000000..bda2ec37f63a5 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern16.js @@ -0,0 +1,60 @@ +//// [iterableArrayPattern16.ts] +function fun(...[a, b]: [Bar, Bar][]) { } +fun(...new FooIteratorIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class FooIteratorIterator { + next() { + return { + value: new FooIterator, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern16.js] +function fun(...[a, b]) { } +fun(...new FooIteratorIterator); +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class FooIteratorIterator { + next() { + return { + value: new FooIterator, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern17.errors.txt b/tests/baselines/reference/iterableArrayPattern17.errors.txt new file mode 100644 index 0000000000000..306b00ea99067 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern17.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts(2,5): error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type 'Bar'. + Property 'x' is missing in type 'FooIterator'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts (1 errors) ==== + function fun(...[a, b]: Bar[]) { } + fun(new FooIterator); + ~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type 'Bar'. +!!! error TS2345: Property 'x' is missing in type 'FooIterator'. + class Bar { x } + class Foo extends Bar { y } + class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern17.js b/tests/baselines/reference/iterableArrayPattern17.js new file mode 100644 index 0000000000000..c6274aabcd9e3 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern17.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern17.ts] +function fun(...[a, b]: Bar[]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern17.js] +function fun(...[a, b]) { } +fun(new FooIterator); +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern18.errors.txt b/tests/baselines/reference/iterableArrayPattern18.errors.txt new file mode 100644 index 0000000000000..c6f8c5e28bd10 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern18.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts(2,5): error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type 'Bar[]'. + Property 'length' is missing in type 'FooIterator'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts (1 errors) ==== + function fun([a, b]: Bar[]) { } + fun(new FooIterator); + ~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type 'FooIterator' is not assignable to parameter of type 'Bar[]'. +!!! error TS2345: Property 'length' is missing in type 'FooIterator'. + class Bar { x } + class Foo extends Bar { y } + class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern18.js b/tests/baselines/reference/iterableArrayPattern18.js new file mode 100644 index 0000000000000..e2016c476905f --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern18.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern18.ts] +function fun([a, b]: Bar[]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern18.js] +function fun([a, b]) { } +fun(new FooIterator); +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern19.errors.txt b/tests/baselines/reference/iterableArrayPattern19.errors.txt new file mode 100644 index 0000000000000..3f8b550d287b9 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern19.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts(2,5): error TS2345: Argument of type 'FooArrayIterator' is not assignable to parameter of type 'Bar[][]'. + Property 'length' is missing in type 'FooArrayIterator'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts (1 errors) ==== + function fun([[a], b]: Bar[][]) { } + fun(new FooArrayIterator); + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type 'FooArrayIterator' is not assignable to parameter of type 'Bar[][]'. +!!! error TS2345: Property 'length' is missing in type 'FooArrayIterator'. + class Bar { x } + class Foo extends Bar { y } + class FooArrayIterator { + next() { + return { + value: [new Foo], + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern19.js b/tests/baselines/reference/iterableArrayPattern19.js new file mode 100644 index 0000000000000..bc3cf33afc2c7 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern19.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern19.ts] +function fun([[a], b]: Bar[][]) { } +fun(new FooArrayIterator); +class Bar { x } +class Foo extends Bar { y } +class FooArrayIterator { + next() { + return { + value: [new Foo], + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern19.js] +function fun([[a], b]) { } +fun(new FooArrayIterator); +class Bar { +} +class Foo extends Bar { +} +class FooArrayIterator { + next() { + return { + value: [new Foo], + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern2.js b/tests/baselines/reference/iterableArrayPattern2.js new file mode 100644 index 0000000000000..7392db7d6b240 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern2.js @@ -0,0 +1,28 @@ +//// [iterableArrayPattern2.ts] +var [a, ...b] = new SymbolIterator; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern2.js] +var [a, ...b] = new SymbolIterator; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern2.types b/tests/baselines/reference/iterableArrayPattern2.types new file mode 100644 index 0000000000000..819516dfe0573 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern2.types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern2.ts === +var [a, ...b] = new SymbolIterator; +>a : symbol +>b : symbol[] +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern20.js b/tests/baselines/reference/iterableArrayPattern20.js new file mode 100644 index 0000000000000..489f97a29f3a3 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern20.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern20.ts] +function fun(...[[a = new Foo], b = [new Foo]]: Bar[][]) { } +fun(...new FooArrayIterator); +class Bar { x } +class Foo extends Bar { y } +class FooArrayIterator { + next() { + return { + value: [new Foo], + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern20.js] +function fun(...[[a = new Foo], b = [new Foo]]) { } +fun(...new FooArrayIterator); +class Bar { +} +class Foo extends Bar { +} +class FooArrayIterator { + next() { + return { + value: [new Foo], + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern20.types b/tests/baselines/reference/iterableArrayPattern20.types new file mode 100644 index 0000000000000..055dfa9585977 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern20.types @@ -0,0 +1,58 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern20.ts === +function fun(...[[a = new Foo], b = [new Foo]]: Bar[][]) { } +>fun : (...[[a = new Foo], b = [new Foo]]: Bar[][]) => void +>a : Bar +>new Foo : Foo +>Foo : typeof Foo +>b : Bar[] +>[new Foo] : Foo[] +>new Foo : Foo +>Foo : typeof Foo +>Bar : Bar + +fun(...new FooArrayIterator); +>fun(...new FooArrayIterator) : void +>fun : (...[[a = new Foo], b = [new Foo]]: Bar[][]) => void +>...new FooArrayIterator : Foo[] +>new FooArrayIterator : FooArrayIterator +>FooArrayIterator : typeof FooArrayIterator + +class Bar { x } +>Bar : Bar +>x : any + +class Foo extends Bar { y } +>Foo : Foo +>Bar : Bar +>y : any + +class FooArrayIterator { +>FooArrayIterator : FooArrayIterator + + next() { +>next : () => { value: Foo[]; done: boolean; } + + return { +>{ value: [new Foo], done: false } : { value: Foo[]; done: boolean; } + + value: [new Foo], +>value : Foo[] +>[new Foo] : Foo[] +>new Foo : Foo +>Foo : typeof Foo + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : FooArrayIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern21.errors.txt b/tests/baselines/reference/iterableArrayPattern21.errors.txt new file mode 100644 index 0000000000000..7e853c90b249d --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern21.errors.txt @@ -0,0 +1,7 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts(1,5): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts (1 errors) ==== + var [a, b] = { 0: "", 1: true }; + ~~~~~~ +!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern21.js b/tests/baselines/reference/iterableArrayPattern21.js new file mode 100644 index 0000000000000..bdc4d401e5453 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern21.js @@ -0,0 +1,5 @@ +//// [iterableArrayPattern21.ts] +var [a, b] = { 0: "", 1: true }; + +//// [iterableArrayPattern21.js] +var [a, b] = { 0: "", 1: true }; diff --git a/tests/baselines/reference/iterableArrayPattern22.errors.txt b/tests/baselines/reference/iterableArrayPattern22.errors.txt new file mode 100644 index 0000000000000..3e40e4fd60255 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern22.errors.txt @@ -0,0 +1,7 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts(1,5): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts (1 errors) ==== + var [...a] = { 0: "", 1: true }; + ~~~~~~ +!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern22.js b/tests/baselines/reference/iterableArrayPattern22.js new file mode 100644 index 0000000000000..9ec41bd307620 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern22.js @@ -0,0 +1,5 @@ +//// [iterableArrayPattern22.ts] +var [...a] = { 0: "", 1: true }; + +//// [iterableArrayPattern22.js] +var [...a] = { 0: "", 1: true }; diff --git a/tests/baselines/reference/iterableArrayPattern23.errors.txt b/tests/baselines/reference/iterableArrayPattern23.errors.txt new file mode 100644 index 0000000000000..1df5d909aedf4 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern23.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts(2,1): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts (1 errors) ==== + var a: string, b: boolean; + [a, b] = { 0: "", 1: true }; + ~~~~~~ +!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern23.js b/tests/baselines/reference/iterableArrayPattern23.js new file mode 100644 index 0000000000000..d932c29506d7a --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern23.js @@ -0,0 +1,7 @@ +//// [iterableArrayPattern23.ts] +var a: string, b: boolean; +[a, b] = { 0: "", 1: true }; + +//// [iterableArrayPattern23.js] +var a, b; +[a, b] = { 0: "", 1: true }; diff --git a/tests/baselines/reference/iterableArrayPattern24.errors.txt b/tests/baselines/reference/iterableArrayPattern24.errors.txt new file mode 100644 index 0000000000000..e954c59f2eadd --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern24.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts(2,1): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts (1 errors) ==== + var a: string, b: boolean[]; + [a, ...b] = { 0: "", 1: true }; + ~~~~~~~~~ +!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern24.js b/tests/baselines/reference/iterableArrayPattern24.js new file mode 100644 index 0000000000000..f089e35dad802 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern24.js @@ -0,0 +1,7 @@ +//// [iterableArrayPattern24.ts] +var a: string, b: boolean[]; +[a, ...b] = { 0: "", 1: true }; + +//// [iterableArrayPattern24.js] +var a, b; +[a, ...b] = { 0: "", 1: true }; diff --git a/tests/baselines/reference/iterableArrayPattern25.errors.txt b/tests/baselines/reference/iterableArrayPattern25.errors.txt new file mode 100644 index 0000000000000..cc901523b55d8 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern25.errors.txt @@ -0,0 +1,8 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts(1,30): error TS2370: A rest parameter must be of an array type. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts (1 errors) ==== + function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { } + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2370: A rest parameter must be of an array type. + takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern25.js b/tests/baselines/reference/iterableArrayPattern25.js new file mode 100644 index 0000000000000..1dc44c0dba705 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern25.js @@ -0,0 +1,7 @@ +//// [iterableArrayPattern25.ts] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { } +takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); + +//// [iterableArrayPattern25.js] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { } +takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); diff --git a/tests/baselines/reference/iterableArrayPattern26.errors.txt b/tests/baselines/reference/iterableArrayPattern26.errors.txt new file mode 100644 index 0000000000000..9fb3e6880398f --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern26.errors.txt @@ -0,0 +1,10 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts(2,21): error TS2345: Argument of type 'Map' is not assignable to parameter of type '[string, number]'. + Property '0' is missing in type 'Map'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts (1 errors) ==== + function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } + takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type 'Map' is not assignable to parameter of type '[string, number]'. +!!! error TS2345: Property '0' is missing in type 'Map'. \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern26.js b/tests/baselines/reference/iterableArrayPattern26.js new file mode 100644 index 0000000000000..63c188febb772 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern26.js @@ -0,0 +1,7 @@ +//// [iterableArrayPattern26.ts] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } +takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); + +//// [iterableArrayPattern26.js] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { } +takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); diff --git a/tests/baselines/reference/iterableArrayPattern27.js b/tests/baselines/reference/iterableArrayPattern27.js new file mode 100644 index 0000000000000..3e936eb51f4b3 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern27.js @@ -0,0 +1,7 @@ +//// [iterableArrayPattern27.ts] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } +takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]])); + +//// [iterableArrayPattern27.js] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { } +takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]])); diff --git a/tests/baselines/reference/iterableArrayPattern27.types b/tests/baselines/reference/iterableArrayPattern27.types new file mode 100644 index 0000000000000..72d13ee0e001c --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern27.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern27.ts === +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } +>takeFirstTwoEntries : (...[[k1, v1], [k2, v2]]: [string, number][]) => void +>k1 : string +>v1 : number +>k2 : string +>v2 : number + +takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]])); +>takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]])) : void +>takeFirstTwoEntries : (...[[k1, v1], [k2, v2]]: [string, number][]) => void +>...new Map([["", 0], ["hello", 1]]) : [string, number] +>new Map([["", 0], ["hello", 1]]) : Map +>Map : MapConstructor +>[["", 0], ["hello", 1]] : [string, number][] +>["", 0] : [string, number] +>["hello", 1] : [string, number] + diff --git a/tests/baselines/reference/iterableArrayPattern28.errors.txt b/tests/baselines/reference/iterableArrayPattern28.errors.txt new file mode 100644 index 0000000000000..0190dd939e8e0 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern28.errors.txt @@ -0,0 +1,10 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts(2,28): error TS2453: The type argument for type parameter 'V' cannot be inferred from the usage. Consider specifying the type arguments explicitly. + Type argument candidate 'number' is not a valid type argument because it is not a supertype of candidate 'boolean'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts (1 errors) ==== + function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } + takeFirstTwoEntries(...new Map([["", 0], ["hello", true]])); + ~~~ +!!! error TS2453: The type argument for type parameter 'V' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +!!! error TS2453: Type argument candidate 'number' is not a valid type argument because it is not a supertype of candidate 'boolean'. \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern28.js b/tests/baselines/reference/iterableArrayPattern28.js new file mode 100644 index 0000000000000..7095347537238 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern28.js @@ -0,0 +1,7 @@ +//// [iterableArrayPattern28.ts] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } +takeFirstTwoEntries(...new Map([["", 0], ["hello", true]])); + +//// [iterableArrayPattern28.js] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { } +takeFirstTwoEntries(...new Map([["", 0], ["hello", true]])); diff --git a/tests/baselines/reference/iterableArrayPattern29.errors.txt b/tests/baselines/reference/iterableArrayPattern29.errors.txt new file mode 100644 index 0000000000000..632854ae952f3 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern29.errors.txt @@ -0,0 +1,12 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts(2,21): error TS2345: Argument of type '[string, boolean]' is not assignable to parameter of type '[string, number]'. + Types of property '1' are incompatible. + Type 'boolean' is not assignable to type 'number'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts (1 errors) ==== + function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } + takeFirstTwoEntries(...new Map([["", true], ["hello", true]])); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '[string, boolean]' is not assignable to parameter of type '[string, number]'. +!!! error TS2345: Types of property '1' are incompatible. +!!! error TS2345: Type 'boolean' is not assignable to type 'number'. \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern29.js b/tests/baselines/reference/iterableArrayPattern29.js new file mode 100644 index 0000000000000..912d336263fe5 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern29.js @@ -0,0 +1,7 @@ +//// [iterableArrayPattern29.ts] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } +takeFirstTwoEntries(...new Map([["", true], ["hello", true]])); + +//// [iterableArrayPattern29.js] +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { } +takeFirstTwoEntries(...new Map([["", true], ["hello", true]])); diff --git a/tests/baselines/reference/iterableArrayPattern3.js b/tests/baselines/reference/iterableArrayPattern3.js new file mode 100644 index 0000000000000..7136c6ab209a6 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern3.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern3.ts] +var a: Bar, b: Bar; +[a, b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern3.js] +var a, b; +[a, b] = new FooIterator; +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern3.types b/tests/baselines/reference/iterableArrayPattern3.types new file mode 100644 index 0000000000000..291eed9723a81 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern3.types @@ -0,0 +1,53 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern3.ts === +var a: Bar, b: Bar; +>a : Bar +>Bar : Bar +>b : Bar +>Bar : Bar + +[a, b] = new FooIterator; +>[a, b] = new FooIterator : FooIterator +>[a, b] : [Bar, Bar] +>a : Bar +>b : Bar +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +class Bar { x } +>Bar : Bar +>x : any + +class Foo extends Bar { y } +>Foo : Foo +>Bar : Bar +>y : any + +class FooIterator { +>FooIterator : FooIterator + + next() { +>next : () => { value: Foo; done: boolean; } + + return { +>{ value: new Foo, done: false } : { value: Foo; done: boolean; } + + value: new Foo, +>value : Foo +>new Foo : Foo +>Foo : typeof Foo + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : FooIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern30.js b/tests/baselines/reference/iterableArrayPattern30.js new file mode 100644 index 0000000000000..10f7df53aa3f5 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern30.js @@ -0,0 +1,5 @@ +//// [iterableArrayPattern30.ts] +const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]) + +//// [iterableArrayPattern30.js] +const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]); diff --git a/tests/baselines/reference/iterableArrayPattern30.types b/tests/baselines/reference/iterableArrayPattern30.types new file mode 100644 index 0000000000000..998da11d65164 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern30.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern30.ts === +const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]) +>k1 : string +>v1 : boolean +>k2 : string +>v2 : boolean +>new Map([["", true], ["hello", true]]) : Map +>Map : MapConstructor +>[["", true], ["hello", true]] : [string, boolean][] +>["", true] : [string, boolean] +>["hello", true] : [string, boolean] + diff --git a/tests/baselines/reference/iterableArrayPattern4.js b/tests/baselines/reference/iterableArrayPattern4.js new file mode 100644 index 0000000000000..6e60dadbd7a74 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern4.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern4.ts] +var a: Bar, b: Bar[]; +[a, ...b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern4.js] +var a, b; +[a, ...b] = new FooIterator; +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern4.types b/tests/baselines/reference/iterableArrayPattern4.types new file mode 100644 index 0000000000000..531b2aa8275be --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern4.types @@ -0,0 +1,54 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern4.ts === +var a: Bar, b: Bar[]; +>a : Bar +>Bar : Bar +>b : Bar[] +>Bar : Bar + +[a, ...b] = new FooIterator; +>[a, ...b] = new FooIterator : FooIterator +>[a, ...b] : Bar[] +>a : Bar +>...b : Bar +>b : Bar[] +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +class Bar { x } +>Bar : Bar +>x : any + +class Foo extends Bar { y } +>Foo : Foo +>Bar : Bar +>y : any + +class FooIterator { +>FooIterator : FooIterator + + next() { +>next : () => { value: Foo; done: boolean; } + + return { +>{ value: new Foo, done: false } : { value: Foo; done: boolean; } + + value: new Foo, +>value : Foo +>new Foo : Foo +>Foo : typeof Foo + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : FooIterator + } +} diff --git a/tests/baselines/reference/iterableArrayPattern5.errors.txt b/tests/baselines/reference/iterableArrayPattern5.errors.txt new file mode 100644 index 0000000000000..ca540d805bee6 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern5.errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts(2,5): error TS2322: Type 'Foo' is not assignable to type 'string'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts (1 errors) ==== + var a: Bar, b: string; + [a, b] = new FooIterator; + ~ +!!! error TS2322: Type 'Foo' is not assignable to type 'string'. + class Bar { x } + class Foo extends Bar { y } + class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern5.js b/tests/baselines/reference/iterableArrayPattern5.js new file mode 100644 index 0000000000000..77e71cac6d383 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern5.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern5.ts] +var a: Bar, b: string; +[a, b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern5.js] +var a, b; +[a, b] = new FooIterator; +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern6.errors.txt b/tests/baselines/reference/iterableArrayPattern6.errors.txt new file mode 100644 index 0000000000000..e0a546d154cc3 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern6.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts(2,8): error TS2322: Type 'Foo[]' is not assignable to type 'string[]'. + Type 'Foo' is not assignable to type 'string'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts (1 errors) ==== + var a: Bar, b: string[]; + [a, ...b] = new FooIterator; + ~ +!!! error TS2322: Type 'Foo[]' is not assignable to type 'string[]'. +!!! error TS2322: Type 'Foo' is not assignable to type 'string'. + class Bar { x } + class Foo extends Bar { y } + class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern6.js b/tests/baselines/reference/iterableArrayPattern6.js new file mode 100644 index 0000000000000..8c797e819f50e --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern6.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern6.ts] +var a: Bar, b: string[]; +[a, ...b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern6.js] +var a, b; +[a, ...b] = new FooIterator; +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern7.errors.txt b/tests/baselines/reference/iterableArrayPattern7.errors.txt new file mode 100644 index 0000000000000..997cc21f38be2 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern7.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts(2,5): error TS2322: Type 'Foo' is not assignable to type 'string[]'. + Property 'length' is missing in type 'Foo'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts (1 errors) ==== + var a: Bar, b: string[]; + [a, b] = new FooIterator; + ~ +!!! error TS2322: Type 'Foo' is not assignable to type 'string[]'. +!!! error TS2322: Property 'length' is missing in type 'Foo'. + class Bar { x } + class Foo extends Bar { y } + class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern7.js b/tests/baselines/reference/iterableArrayPattern7.js new file mode 100644 index 0000000000000..3f79e6bfba89a --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern7.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern7.ts] +var a: Bar, b: string[]; +[a, b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern7.js] +var a, b; +[a, b] = new FooIterator; +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern8.errors.txt b/tests/baselines/reference/iterableArrayPattern8.errors.txt new file mode 100644 index 0000000000000..c06e0c9543fb9 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern8.errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts(2,8): error TS2322: Type 'Foo[]' is not assignable to type 'string'. + + +==== tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts (1 errors) ==== + var a: Bar, b: string; + [a, ...b] = new FooIterator; + ~ +!!! error TS2322: Type 'Foo[]' is not assignable to type 'string'. + class Bar { x } + class Foo extends Bar { y } + class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iterableArrayPattern8.js b/tests/baselines/reference/iterableArrayPattern8.js new file mode 100644 index 0000000000000..dd1c76c1f51dd --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern8.js @@ -0,0 +1,36 @@ +//// [iterableArrayPattern8.ts] +var a: Bar, b: string; +[a, ...b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern8.js] +var a, b; +[a, ...b] = new FooIterator; +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern9.js b/tests/baselines/reference/iterableArrayPattern9.js new file mode 100644 index 0000000000000..a85ca9c347b2c --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern9.js @@ -0,0 +1,34 @@ +//// [iterableArrayPattern9.ts] +function fun([a, b] = new FooIterator) { } +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iterableArrayPattern9.js] +function fun([a, b] = new FooIterator) { } +class Bar { +} +class Foo extends Bar { +} +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iterableArrayPattern9.types b/tests/baselines/reference/iterableArrayPattern9.types new file mode 100644 index 0000000000000..67d4bab1a8384 --- /dev/null +++ b/tests/baselines/reference/iterableArrayPattern9.types @@ -0,0 +1,46 @@ +=== tests/cases/conformance/es6/destructuring/iterableArrayPattern9.ts === +function fun([a, b] = new FooIterator) { } +>fun : ([a, b]?: FooIterator) => void +>a : Foo +>b : Foo +>new FooIterator : FooIterator +>FooIterator : typeof FooIterator + +class Bar { x } +>Bar : Bar +>x : any + +class Foo extends Bar { y } +>Foo : Foo +>Bar : Bar +>y : any + +class FooIterator { +>FooIterator : FooIterator + + next() { +>next : () => { value: Foo; done: boolean; } + + return { +>{ value: new Foo, done: false } : { value: Foo; done: boolean; } + + value: new Foo, +>value : Foo +>new Foo : Foo +>Foo : typeof Foo + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : FooIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray.js b/tests/baselines/reference/iteratorSpreadInArray.js new file mode 100644 index 0000000000000..8e25a2e7ecf55 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray.js @@ -0,0 +1,29 @@ +//// [iteratorSpreadInArray.ts] +var array = [...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInArray.js] +var array = [...new SymbolIterator]; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray.types b/tests/baselines/reference/iteratorSpreadInArray.types new file mode 100644 index 0000000000000..13b1a458eb975 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray.types @@ -0,0 +1,37 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInArray.ts === +var array = [...new SymbolIterator]; +>array : symbol[] +>[...new SymbolIterator] : symbol[] +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray10.errors.txt b/tests/baselines/reference/iteratorSpreadInArray10.errors.txt new file mode 100644 index 0000000000000..90cde7d03b119 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray10.errors.txt @@ -0,0 +1,13 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts(1,17): error TS2489: An iterator must have a 'next()' method. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts (1 errors) ==== + var array = [...new SymbolIterator]; + ~~~~~~~~~~~~~~~~~~ +!!! error TS2489: An iterator must have a 'next()' method. + + class SymbolIterator { + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInArray10.js b/tests/baselines/reference/iteratorSpreadInArray10.js new file mode 100644 index 0000000000000..1004dbd7b3458 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray10.js @@ -0,0 +1,16 @@ +//// [iteratorSpreadInArray10.ts] +var array = [...new SymbolIterator]; + +class SymbolIterator { + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInArray10.js] +var array = [...new SymbolIterator]; +class SymbolIterator { + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray11.js b/tests/baselines/reference/iteratorSpreadInArray11.js new file mode 100644 index 0000000000000..fa86c1521239a --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray11.js @@ -0,0 +1,7 @@ +//// [iteratorSpreadInArray11.ts] +var iter: Iterable; +var array = [...iter]; + +//// [iteratorSpreadInArray11.js] +var iter; +var array = [...iter]; diff --git a/tests/baselines/reference/iteratorSpreadInArray11.types b/tests/baselines/reference/iteratorSpreadInArray11.types new file mode 100644 index 0000000000000..a3ed7826e071a --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray11.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts === +var iter: Iterable; +>iter : Iterable +>Iterable : Iterable + +var array = [...iter]; +>array : number[] +>[...iter] : number[] +>...iter : number +>iter : Iterable + diff --git a/tests/baselines/reference/iteratorSpreadInArray2.js b/tests/baselines/reference/iteratorSpreadInArray2.js new file mode 100644 index 0000000000000..aa4a1099a40dd --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray2.js @@ -0,0 +1,53 @@ +//// [iteratorSpreadInArray2.ts] +var array = [...new NumberIterator, ...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class NumberIterator { + next() { + return { + value: 0, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInArray2.js] +var array = [...new NumberIterator, ...new SymbolIterator]; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class NumberIterator { + next() { + return { + value: 0, + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray2.types b/tests/baselines/reference/iteratorSpreadInArray2.types new file mode 100644 index 0000000000000..3cb27445f5792 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray2.types @@ -0,0 +1,68 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInArray2.ts === +var array = [...new NumberIterator, ...new SymbolIterator]; +>array : (number | symbol)[] +>[...new NumberIterator, ...new SymbolIterator] : (number | symbol)[] +>...new NumberIterator : number +>new NumberIterator : NumberIterator +>NumberIterator : typeof NumberIterator +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} + +class NumberIterator { +>NumberIterator : NumberIterator + + next() { +>next : () => { value: number; done: boolean; } + + return { +>{ value: 0, done: false } : { value: number; done: boolean; } + + value: 0, +>value : number + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : NumberIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray3.js b/tests/baselines/reference/iteratorSpreadInArray3.js new file mode 100644 index 0000000000000..1d468e4483e46 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray3.js @@ -0,0 +1,29 @@ +//// [iteratorSpreadInArray3.ts] +var array = [...[0, 1], ...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInArray3.js] +var array = [...[0, 1], ...new SymbolIterator]; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray3.types b/tests/baselines/reference/iteratorSpreadInArray3.types new file mode 100644 index 0000000000000..e5c25daabc79a --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray3.types @@ -0,0 +1,39 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInArray3.ts === +var array = [...[0, 1], ...new SymbolIterator]; +>array : (number | symbol)[] +>[...[0, 1], ...new SymbolIterator] : (number | symbol)[] +>...[0, 1] : number +>[0, 1] : number[] +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray4.js b/tests/baselines/reference/iteratorSpreadInArray4.js new file mode 100644 index 0000000000000..82a08bfa96474 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray4.js @@ -0,0 +1,29 @@ +//// [iteratorSpreadInArray4.ts] +var array = [0, 1, ...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInArray4.js] +var array = [0, 1, ...new SymbolIterator]; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray4.types b/tests/baselines/reference/iteratorSpreadInArray4.types new file mode 100644 index 0000000000000..790fc9db1ba22 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray4.types @@ -0,0 +1,37 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInArray4.ts === +var array = [0, 1, ...new SymbolIterator]; +>array : (number | symbol)[] +>[0, 1, ...new SymbolIterator] : (number | symbol)[] +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray5.errors.txt b/tests/baselines/reference/iteratorSpreadInArray5.errors.txt new file mode 100644 index 0000000000000..498cc7d48efdb --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray5.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts(1,5): error TS2322: Type '(number | symbol)[]' is not assignable to type 'number[]'. + Type 'number | symbol' is not assignable to type 'number'. + Type 'symbol' is not assignable to type 'number'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts (1 errors) ==== + var array: number[] = [0, 1, ...new SymbolIterator]; + ~~~~~ +!!! error TS2322: Type '(number | symbol)[]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'number | symbol' is not assignable to type 'number'. +!!! error TS2322: Type 'symbol' is not assignable to type 'number'. + + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInArray5.js b/tests/baselines/reference/iteratorSpreadInArray5.js new file mode 100644 index 0000000000000..0aa158a5dc26e --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray5.js @@ -0,0 +1,29 @@ +//// [iteratorSpreadInArray5.ts] +var array: number[] = [0, 1, ...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInArray5.js] +var array = [0, 1, ...new SymbolIterator]; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray6.errors.txt b/tests/baselines/reference/iteratorSpreadInArray6.errors.txt new file mode 100644 index 0000000000000..b90ac5f203c18 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray6.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts(2,14): error TS2345: Argument of type 'symbol[]' is not assignable to parameter of type 'number'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts (1 errors) ==== + var array: number[] = [0, 1]; + array.concat([...new SymbolIterator]); + ~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type 'symbol[]' is not assignable to parameter of type 'number'. + + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInArray6.js b/tests/baselines/reference/iteratorSpreadInArray6.js new file mode 100644 index 0000000000000..02d1c435b8cec --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray6.js @@ -0,0 +1,31 @@ +//// [iteratorSpreadInArray6.ts] +var array: number[] = [0, 1]; +array.concat([...new SymbolIterator]); + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInArray6.js] +var array = [0, 1]; +array.concat([...new SymbolIterator]); +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray7.js b/tests/baselines/reference/iteratorSpreadInArray7.js new file mode 100644 index 0000000000000..72a614ae4ec22 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray7.js @@ -0,0 +1,31 @@ +//// [iteratorSpreadInArray7.ts] +var array: symbol[]; +array.concat([...new SymbolIterator]); + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInArray7.js] +var array; +array.concat([...new SymbolIterator]); +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray7.types b/tests/baselines/reference/iteratorSpreadInArray7.types new file mode 100644 index 0000000000000..c58d01f098bf6 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray7.types @@ -0,0 +1,43 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInArray7.ts === +var array: symbol[]; +>array : symbol[] + +array.concat([...new SymbolIterator]); +>array.concat([...new SymbolIterator]) : symbol[] +>array.concat : { (...items: U[]): symbol[]; (...items: symbol[]): symbol[]; } +>array : symbol[] +>concat : { (...items: U[]): symbol[]; (...items: symbol[]): symbol[]; } +>[...new SymbolIterator] : symbol[] +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray8.errors.txt b/tests/baselines/reference/iteratorSpreadInArray8.errors.txt new file mode 100644 index 0000000000000..365bc8db9c2f9 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray8.errors.txt @@ -0,0 +1,16 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts(1,17): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts (1 errors) ==== + var array = [...new SymbolIterator]; + ~~~~~~~~~~~~~~~~~~ +!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator. + + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInArray8.js b/tests/baselines/reference/iteratorSpreadInArray8.js new file mode 100644 index 0000000000000..083786991298e --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray8.js @@ -0,0 +1,22 @@ +//// [iteratorSpreadInArray8.ts] +var array = [...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } +} + +//// [iteratorSpreadInArray8.js] +var array = [...new SymbolIterator]; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInArray9.errors.txt b/tests/baselines/reference/iteratorSpreadInArray9.errors.txt new file mode 100644 index 0000000000000..e0e3d061f169a --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray9.errors.txt @@ -0,0 +1,33 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts(1,17): error TS2322: Type 'SymbolIterator' is not assignable to type 'Iterable'. + Types of property '[Symbol.iterator]' are incompatible. + Type '() => SymbolIterator' is not assignable to type '() => Iterator'. + Type 'SymbolIterator' is not assignable to type 'Iterator'. + Types of property 'next' are incompatible. + Type '() => { value: symbol; }' is not assignable to type '() => IteratorResult'. + Type '{ value: symbol; }' is not assignable to type 'IteratorResult'. + Property 'done' is missing in type '{ value: symbol; }'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts (1 errors) ==== + var array = [...new SymbolIterator]; + ~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'SymbolIterator' is not assignable to type 'Iterable'. +!!! error TS2322: Types of property '[Symbol.iterator]' are incompatible. +!!! error TS2322: Type '() => SymbolIterator' is not assignable to type '() => Iterator'. +!!! error TS2322: Type 'SymbolIterator' is not assignable to type 'Iterator'. +!!! error TS2322: Types of property 'next' are incompatible. +!!! error TS2322: Type '() => { value: symbol; }' is not assignable to type '() => IteratorResult'. +!!! error TS2322: Type '{ value: symbol; }' is not assignable to type 'IteratorResult'. +!!! error TS2322: Property 'done' is missing in type '{ value: symbol; }'. + + class SymbolIterator { + next() { + return { + value: Symbol() + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInArray9.js b/tests/baselines/reference/iteratorSpreadInArray9.js new file mode 100644 index 0000000000000..ed0a9b4ebe921 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInArray9.js @@ -0,0 +1,27 @@ +//// [iteratorSpreadInArray9.ts] +var array = [...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol() + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInArray9.js] +var array = [...new SymbolIterator]; +class SymbolIterator { + next() { + return { + value: Symbol() + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall.errors.txt b/tests/baselines/reference/iteratorSpreadInCall.errors.txt new file mode 100644 index 0000000000000..614153192d711 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts (1 errors) ==== + foo(...new SymbolIterator); + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + + function foo(s: symbol) { } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall.js b/tests/baselines/reference/iteratorSpreadInCall.js new file mode 100644 index 0000000000000..f3bf17c032778 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall.js @@ -0,0 +1,31 @@ +//// [iteratorSpreadInCall.ts] +foo(...new SymbolIterator); + +function foo(s: symbol) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall.js] +foo(...new SymbolIterator); +function foo(s) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall10.errors.txt b/tests/baselines/reference/iteratorSpreadInCall10.errors.txt new file mode 100644 index 0000000000000..04d9045e86c3e --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall10.errors.txt @@ -0,0 +1,22 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts (1 errors) ==== + foo(...new SymbolIterator); + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + + function foo(s: T[]) { return s[0] } + + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall10.js b/tests/baselines/reference/iteratorSpreadInCall10.js new file mode 100644 index 0000000000000..14a08c970091a --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall10.js @@ -0,0 +1,32 @@ +//// [iteratorSpreadInCall10.ts] +foo(...new SymbolIterator); + +function foo(s: T[]) { return s[0] } + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall10.js] +foo(...new SymbolIterator); +function foo(s) { return s[0]; } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall11.js b/tests/baselines/reference/iteratorSpreadInCall11.js new file mode 100644 index 0000000000000..d01eb259ef3a3 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall11.js @@ -0,0 +1,32 @@ +//// [iteratorSpreadInCall11.ts] +foo(...new SymbolIterator); + +function foo(...s: T[]) { return s[0] } + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall11.js] +foo(...new SymbolIterator); +function foo(...s) { return s[0]; } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall11.types b/tests/baselines/reference/iteratorSpreadInCall11.types new file mode 100644 index 0000000000000..a37fc6e2232e3 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall11.types @@ -0,0 +1,45 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts === +foo(...new SymbolIterator); +>foo(...new SymbolIterator) : symbol +>foo : (...s: T[]) => T +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +function foo(...s: T[]) { return s[0] } +>foo : (...s: T[]) => T +>T : T +>s : T[] +>T : T +>s[0] : T +>s : T[] + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall12.js b/tests/baselines/reference/iteratorSpreadInCall12.js new file mode 100644 index 0000000000000..90b9d9b900b5e --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall12.js @@ -0,0 +1,61 @@ +//// [iteratorSpreadInCall12.ts] +new Foo(...[...new SymbolIterator, ...[...new StringIterator]]); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall12.js] +new Foo(...[...new SymbolIterator, ...[...new StringIterator]]); +class Foo { + constructor(...s) { + } +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall12.types b/tests/baselines/reference/iteratorSpreadInCall12.types new file mode 100644 index 0000000000000..78ce973a53224 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall12.types @@ -0,0 +1,81 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts === +new Foo(...[...new SymbolIterator, ...[...new StringIterator]]); +>new Foo(...[...new SymbolIterator, ...[...new StringIterator]]) : Foo +>Foo : typeof Foo +>...[...new SymbolIterator, ...[...new StringIterator]] : string | symbol +>[...new SymbolIterator, ...[...new StringIterator]] : (string | symbol)[] +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator +>...[...new StringIterator] : string +>[...new StringIterator] : string[] +>...new StringIterator : string +>new StringIterator : StringIterator +>StringIterator : typeof StringIterator + +class Foo { +>Foo : Foo +>T : T + + constructor(...s: T[]) { } +>s : T[] +>T : T +} + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} + +class StringIterator { +>StringIterator : StringIterator + + next() { +>next : () => { value: string; done: boolean; } + + return { +>{ value: "", done: false } : { value: string; done: boolean; } + + value: "", +>value : string + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : StringIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall2.errors.txt b/tests/baselines/reference/iteratorSpreadInCall2.errors.txt new file mode 100644 index 0000000000000..bd994ab37b08e --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall2.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts (1 errors) ==== + foo(...new SymbolIterator); + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + + function foo(s: symbol[]) { } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall2.js b/tests/baselines/reference/iteratorSpreadInCall2.js new file mode 100644 index 0000000000000..6c3517857d577 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall2.js @@ -0,0 +1,31 @@ +//// [iteratorSpreadInCall2.ts] +foo(...new SymbolIterator); + +function foo(s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall2.js] +foo(...new SymbolIterator); +function foo(s) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall3.js b/tests/baselines/reference/iteratorSpreadInCall3.js new file mode 100644 index 0000000000000..b33ceae7bfd1c --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall3.js @@ -0,0 +1,31 @@ +//// [iteratorSpreadInCall3.ts] +foo(...new SymbolIterator); + +function foo(...s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall3.js] +foo(...new SymbolIterator); +function foo(...s) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall3.types b/tests/baselines/reference/iteratorSpreadInCall3.types new file mode 100644 index 0000000000000..07eb149ba3171 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall3.types @@ -0,0 +1,41 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts === +foo(...new SymbolIterator); +>foo(...new SymbolIterator) : void +>foo : (...s: symbol[]) => void +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator + +function foo(...s: symbol[]) { } +>foo : (...s: symbol[]) => void +>s : symbol[] + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall4.errors.txt b/tests/baselines/reference/iteratorSpreadInCall4.errors.txt new file mode 100644 index 0000000000000..0e0a40a512f4a --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall4.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts(1,1): error TS2346: Supplied parameters do not match any signature of call target. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts (1 errors) ==== + foo(...new SymbolIterator); + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2346: Supplied parameters do not match any signature of call target. + + function foo(s1: symbol, ...s: symbol[]) { } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall4.js b/tests/baselines/reference/iteratorSpreadInCall4.js new file mode 100644 index 0000000000000..7819a1ba6f9c2 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall4.js @@ -0,0 +1,31 @@ +//// [iteratorSpreadInCall4.ts] +foo(...new SymbolIterator); + +function foo(s1: symbol, ...s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall4.js] +foo(...new SymbolIterator); +function foo(s1, ...s) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall5.js b/tests/baselines/reference/iteratorSpreadInCall5.js new file mode 100644 index 0000000000000..a4a30ee016610 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall5.js @@ -0,0 +1,55 @@ +//// [iteratorSpreadInCall5.ts] +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: (symbol | string)[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall5.js] +foo(...new SymbolIterator, ...new StringIterator); +function foo(...s) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall5.types b/tests/baselines/reference/iteratorSpreadInCall5.types new file mode 100644 index 0000000000000..6e924a1ef42f0 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall5.types @@ -0,0 +1,72 @@ +=== tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts === +foo(...new SymbolIterator, ...new StringIterator); +>foo(...new SymbolIterator, ...new StringIterator) : void +>foo : (...s: (string | symbol)[]) => void +>...new SymbolIterator : symbol +>new SymbolIterator : SymbolIterator +>SymbolIterator : typeof SymbolIterator +>...new StringIterator : string +>new StringIterator : StringIterator +>StringIterator : typeof StringIterator + +function foo(...s: (symbol | string)[]) { } +>foo : (...s: (string | symbol)[]) => void +>s : (string | symbol)[] + +class SymbolIterator { +>SymbolIterator : SymbolIterator + + next() { +>next : () => { value: symbol; done: boolean; } + + return { +>{ value: Symbol(), done: false } : { value: symbol; done: boolean; } + + value: Symbol(), +>value : symbol +>Symbol() : symbol +>Symbol : SymbolConstructor + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : SymbolIterator + } +} + +class StringIterator { +>StringIterator : StringIterator + + next() { +>next : () => { value: string; done: boolean; } + + return { +>{ value: "", done: false } : { value: string; done: boolean; } + + value: "", +>value : string + + done: false +>done : boolean + + }; + } + + [Symbol.iterator]() { +>Symbol.iterator : symbol +>Symbol : SymbolConstructor +>iterator : symbol + + return this; +>this : StringIterator + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall6.errors.txt b/tests/baselines/reference/iteratorSpreadInCall6.errors.txt new file mode 100644 index 0000000000000..be085beb63286 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall6.errors.txt @@ -0,0 +1,36 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts(1,28): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number | symbol'. + Type 'string' is not assignable to type 'symbol'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts (1 errors) ==== + foo(...new SymbolIterator, ...new StringIterator); + ~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number | symbol'. +!!! error TS2345: Type 'string' is not assignable to type 'symbol'. + + function foo(...s: (symbol | number)[]) { } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } + + class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall6.js b/tests/baselines/reference/iteratorSpreadInCall6.js new file mode 100644 index 0000000000000..8ad60be911e46 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall6.js @@ -0,0 +1,55 @@ +//// [iteratorSpreadInCall6.ts] +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: (symbol | number)[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall6.js] +foo(...new SymbolIterator, ...new StringIterator); +function foo(...s) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall7.errors.txt b/tests/baselines/reference/iteratorSpreadInCall7.errors.txt new file mode 100644 index 0000000000000..51cae1d72b259 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall7.errors.txt @@ -0,0 +1,36 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts(1,1): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. + Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts (1 errors) ==== + foo(...new SymbolIterator, ...new StringIterator); + ~~~ +!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +!!! error TS2453: Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + function foo(...s: T[]) { return s[0]; } + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } + + class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall7.js b/tests/baselines/reference/iteratorSpreadInCall7.js new file mode 100644 index 0000000000000..4a56b75d2368e --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall7.js @@ -0,0 +1,55 @@ +//// [iteratorSpreadInCall7.ts] +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: T[]) { return s[0]; } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall7.js] +foo(...new SymbolIterator, ...new StringIterator); +function foo(...s) { return s[0]; } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall8.errors.txt b/tests/baselines/reference/iteratorSpreadInCall8.errors.txt new file mode 100644 index 0000000000000..d7913458b6a13 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall8.errors.txt @@ -0,0 +1,39 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts(1,5): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. + Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts (1 errors) ==== + new Foo(...new SymbolIterator, ...new StringIterator); + ~~~ +!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +!!! error TS2453: Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + class Foo { + constructor(...s: T[]) { } + } + + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } + + class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall8.js b/tests/baselines/reference/iteratorSpreadInCall8.js new file mode 100644 index 0000000000000..ac22bbcf5a37f --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall8.js @@ -0,0 +1,61 @@ +//// [iteratorSpreadInCall8.ts] +new Foo(...new SymbolIterator, ...new StringIterator); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall8.js] +new Foo(...new SymbolIterator, ...new StringIterator); +class Foo { + constructor(...s) { + } +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/baselines/reference/iteratorSpreadInCall9.errors.txt b/tests/baselines/reference/iteratorSpreadInCall9.errors.txt new file mode 100644 index 0000000000000..da2ee7f8efc10 --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall9.errors.txt @@ -0,0 +1,39 @@ +tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts(1,5): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. + Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + +==== tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts (1 errors) ==== + new Foo(...new SymbolIterator, ...[...new StringIterator]); + ~~~ +!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +!!! error TS2453: Type argument candidate 'symbol' is not a valid type argument because it is not a supertype of candidate 'string'. + + class Foo { + constructor(...s: T[]) { } + } + + class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } + + class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/iteratorSpreadInCall9.js b/tests/baselines/reference/iteratorSpreadInCall9.js new file mode 100644 index 0000000000000..2a73ee29c34ce --- /dev/null +++ b/tests/baselines/reference/iteratorSpreadInCall9.js @@ -0,0 +1,61 @@ +//// [iteratorSpreadInCall9.ts] +new Foo(...new SymbolIterator, ...[...new StringIterator]); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +//// [iteratorSpreadInCall9.js] +new Foo(...new SymbolIterator, ...[...new StringIterator]); +class Foo { + constructor(...s) { + } +} +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + [Symbol.iterator]() { + return this; + } +} diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern1.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern1.ts new file mode 100644 index 0000000000000..7b3be0365e953 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern1.ts @@ -0,0 +1,14 @@ +//@target: ES6 +var [a, b] = new SymbolIterator; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts new file mode 100644 index 0000000000000..35d05ef1f9cab --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern10.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun([a, b]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern11.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern11.ts new file mode 100644 index 0000000000000..ed93b5175d014 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern11.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun([a, b] = new FooIterator) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern12.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern12.ts new file mode 100644 index 0000000000000..b7e763694eaa8 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern12.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun([a, ...b] = new FooIterator) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern13.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern13.ts new file mode 100644 index 0000000000000..f0b9b142f4010 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern13.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun([a, ...b]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern14.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern14.ts new file mode 100644 index 0000000000000..c327efa3ec237 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern14.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun(...[a, ...b]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern15.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern15.ts new file mode 100644 index 0000000000000..21d632fd54166 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern15.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun(...[a, b]: Bar[]) { } +fun(...new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts new file mode 100644 index 0000000000000..ba2c74681fe53 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern16.ts @@ -0,0 +1,30 @@ +//@target: ES6 +function fun(...[a, b]: [Bar, Bar][]) { } +fun(...new FooIteratorIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class FooIteratorIterator { + next() { + return { + value: new FooIterator, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts new file mode 100644 index 0000000000000..90db0e5edb5a0 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern17.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun(...[a, b]: Bar[]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts new file mode 100644 index 0000000000000..e6e5ad617b28f --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern18.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun([a, b]: Bar[]) { } +fun(new FooIterator); +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts new file mode 100644 index 0000000000000..8513dd07649c9 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern19.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun([[a], b]: Bar[][]) { } +fun(new FooArrayIterator); +class Bar { x } +class Foo extends Bar { y } +class FooArrayIterator { + next() { + return { + value: [new Foo], + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern2.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern2.ts new file mode 100644 index 0000000000000..587f1f0b05692 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern2.ts @@ -0,0 +1,14 @@ +//@target: ES6 +var [a, ...b] = new SymbolIterator; +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern20.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern20.ts new file mode 100644 index 0000000000000..b5be67b393fb3 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern20.ts @@ -0,0 +1,17 @@ +//@target: ES6 +function fun(...[[a = new Foo], b = [new Foo]]: Bar[][]) { } +fun(...new FooArrayIterator); +class Bar { x } +class Foo extends Bar { y } +class FooArrayIterator { + next() { + return { + value: [new Foo], + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts new file mode 100644 index 0000000000000..c8f17395d1436 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern21.ts @@ -0,0 +1,2 @@ +//@target: ES6 +var [a, b] = { 0: "", 1: true }; \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts new file mode 100644 index 0000000000000..8cf60df559780 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern22.ts @@ -0,0 +1,2 @@ +//@target: ES6 +var [...a] = { 0: "", 1: true }; \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts new file mode 100644 index 0000000000000..91ce911b04cd7 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern23.ts @@ -0,0 +1,3 @@ +//@target: ES6 +var a: string, b: boolean; +[a, b] = { 0: "", 1: true }; \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts new file mode 100644 index 0000000000000..462b3663b8bd3 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern24.ts @@ -0,0 +1,3 @@ +//@target: ES6 +var a: string, b: boolean[]; +[a, ...b] = { 0: "", 1: true }; \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts new file mode 100644 index 0000000000000..a47edb4e98761 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern25.ts @@ -0,0 +1,3 @@ +//@target: ES6 +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]) { } +takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts new file mode 100644 index 0000000000000..be295333b2e74 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern26.ts @@ -0,0 +1,3 @@ +//@target: ES6 +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } +takeFirstTwoEntries(new Map([["", 0], ["hello", 1]])); \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern27.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern27.ts new file mode 100644 index 0000000000000..fcf6967cd4e9c --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern27.ts @@ -0,0 +1,3 @@ +//@target: ES6 +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } +takeFirstTwoEntries(...new Map([["", 0], ["hello", 1]])); \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts new file mode 100644 index 0000000000000..111abd70ac30f --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern28.ts @@ -0,0 +1,3 @@ +//@target: ES6 +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } +takeFirstTwoEntries(...new Map([["", 0], ["hello", true]])); \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts new file mode 100644 index 0000000000000..403347d61e504 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts @@ -0,0 +1,3 @@ +//@target: ES6 +function takeFirstTwoEntries(...[[k1, v1], [k2, v2]]: [string, number][]) { } +takeFirstTwoEntries(...new Map([["", true], ["hello", true]])); \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern3.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern3.ts new file mode 100644 index 0000000000000..31656b5661f9a --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern3.ts @@ -0,0 +1,17 @@ +//@target: ES6 +var a: Bar, b: Bar; +[a, b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern30.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern30.ts new file mode 100644 index 0000000000000..075ff3fd46793 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern30.ts @@ -0,0 +1,2 @@ +//@target: ES6 +const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]) \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern4.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern4.ts new file mode 100644 index 0000000000000..edd95be159859 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern4.ts @@ -0,0 +1,17 @@ +//@target: ES6 +var a: Bar, b: Bar[]; +[a, ...b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts new file mode 100644 index 0000000000000..b51d0f09d089e --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern5.ts @@ -0,0 +1,17 @@ +//@target: ES6 +var a: Bar, b: string; +[a, b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts new file mode 100644 index 0000000000000..fc9395ed6a4f7 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern6.ts @@ -0,0 +1,17 @@ +//@target: ES6 +var a: Bar, b: string[]; +[a, ...b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts new file mode 100644 index 0000000000000..85b2f2e54e304 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern7.ts @@ -0,0 +1,17 @@ +//@target: ES6 +var a: Bar, b: string[]; +[a, b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts new file mode 100644 index 0000000000000..dd49205d6e0e3 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern8.ts @@ -0,0 +1,17 @@ +//@target: ES6 +var a: Bar, b: string; +[a, ...b] = new FooIterator; +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/iterableArrayPattern9.ts b/tests/cases/conformance/es6/destructuring/iterableArrayPattern9.ts new file mode 100644 index 0000000000000..1573c55ca8e92 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/iterableArrayPattern9.ts @@ -0,0 +1,16 @@ +//@target: ES6 +function fun([a, b] = new FooIterator) { } +class Bar { x } +class Foo extends Bar { y } +class FooIterator { + next() { + return { + value: new Foo, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of57.ts b/tests/cases/conformance/es6/for-ofStatements/for-of57.ts new file mode 100644 index 0000000000000..f3c8dd9782291 --- /dev/null +++ b/tests/cases/conformance/es6/for-ofStatements/for-of57.ts @@ -0,0 +1,3 @@ +//@target: ES6 +var iter: Iterable; +for (let num of iter) { } \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray.ts new file mode 100644 index 0000000000000..4b4f3e8cc1c73 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray.ts @@ -0,0 +1,15 @@ +//@target: ES6 +var array = [...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts new file mode 100644 index 0000000000000..f8549b82b76d2 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray10.ts @@ -0,0 +1,8 @@ +//@target: ES6 +var array = [...new SymbolIterator]; + +class SymbolIterator { + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts new file mode 100644 index 0000000000000..0c0108433aaf2 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts @@ -0,0 +1,3 @@ +//@target: ES6 +var iter: Iterable; +var array = [...iter]; \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray2.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray2.ts new file mode 100644 index 0000000000000..9db5d010874f6 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray2.ts @@ -0,0 +1,28 @@ +//@target: ES6 +var array = [...new NumberIterator, ...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class NumberIterator { + next() { + return { + value: 0, + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray3.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray3.ts new file mode 100644 index 0000000000000..174c97de7cc88 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray3.ts @@ -0,0 +1,15 @@ +//@target: ES6 +var array = [...[0, 1], ...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray4.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray4.ts new file mode 100644 index 0000000000000..47c2e63370215 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray4.ts @@ -0,0 +1,15 @@ +//@target: ES6 +var array = [0, 1, ...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts new file mode 100644 index 0000000000000..e6a8041a961c9 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray5.ts @@ -0,0 +1,15 @@ +//@target: ES6 +var array: number[] = [0, 1, ...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts new file mode 100644 index 0000000000000..7495ca6aac6a7 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray6.ts @@ -0,0 +1,16 @@ +//@target: ES6 +var array: number[] = [0, 1]; +array.concat([...new SymbolIterator]); + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray7.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray7.ts new file mode 100644 index 0000000000000..12ca478c73814 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray7.ts @@ -0,0 +1,16 @@ +//@target: ES6 +var array: symbol[]; +array.concat([...new SymbolIterator]); + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts new file mode 100644 index 0000000000000..0e2258aa5eacd --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray8.ts @@ -0,0 +1,11 @@ +//@target: ES6 +var array = [...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts new file mode 100644 index 0000000000000..2b8d93c9ccb67 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts @@ -0,0 +1,14 @@ +//@target: ES6 +var array = [...new SymbolIterator]; + +class SymbolIterator { + next() { + return { + value: Symbol() + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts new file mode 100644 index 0000000000000..85d07e56996c9 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall.ts @@ -0,0 +1,16 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(s: symbol) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts new file mode 100644 index 0000000000000..bf8ad336fbf65 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall10.ts @@ -0,0 +1,17 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(s: T[]) { return s[0] } + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts new file mode 100644 index 0000000000000..182e454cfc8b5 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall11.ts @@ -0,0 +1,17 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(...s: T[]) { return s[0] } + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts new file mode 100644 index 0000000000000..a0bd1ede1937b --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts @@ -0,0 +1,32 @@ +//@target: ES6 +new Foo(...[...new SymbolIterator, ...[...new StringIterator]]); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts new file mode 100644 index 0000000000000..4a8fd9ff389dd --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall2.ts @@ -0,0 +1,16 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts new file mode 100644 index 0000000000000..b6e8fe0c86be1 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall3.ts @@ -0,0 +1,16 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(...s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts new file mode 100644 index 0000000000000..2a73fd6f3c99a --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall4.ts @@ -0,0 +1,16 @@ +//@target: ES6 +foo(...new SymbolIterator); + +function foo(s1: symbol, ...s: symbol[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts new file mode 100644 index 0000000000000..c17c4156e655a --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts @@ -0,0 +1,29 @@ +//@target: ES6 +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: (symbol | string)[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts new file mode 100644 index 0000000000000..2c6150f8040c5 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts @@ -0,0 +1,29 @@ +//@target: ES6 +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: (symbol | number)[]) { } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts new file mode 100644 index 0000000000000..56fb7936eb780 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts @@ -0,0 +1,29 @@ +//@target: ES6 +foo(...new SymbolIterator, ...new StringIterator); + +function foo(...s: T[]) { return s[0]; } +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts new file mode 100644 index 0000000000000..e5b969456b7e8 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts @@ -0,0 +1,32 @@ +//@target: ES6 +new Foo(...new SymbolIterator, ...new StringIterator); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts new file mode 100644 index 0000000000000..470f99844ba18 --- /dev/null +++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts @@ -0,0 +1,32 @@ +//@target: ES6 +new Foo(...new SymbolIterator, ...[...new StringIterator]); + +class Foo { + constructor(...s: T[]) { } +} + +class SymbolIterator { + next() { + return { + value: Symbol(), + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} + +class StringIterator { + next() { + return { + value: "", + done: false + }; + } + + [Symbol.iterator]() { + return this; + } +} \ No newline at end of file