diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 6781f6f1701..f3494783514 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -1120,11 +1120,15 @@ namespace ts { // We add the nodes within the `try` block to the `finally`'s antecedents if there's no catch block // (If there is a `catch` block, it will have all these antecedents instead, and the `finally` will // have the end of the `try` block and the end of the `catch` block) + let preFinallyPrior = preTryFlow; if (!node.catchClause) { if (tryPriors.length) { + const preFinallyFlow = createBranchLabel(); + addAntecedent(preFinallyFlow, preTryFlow); for (const p of tryPriors) { - addAntecedent(preFinallyLabel, p); + addAntecedent(preFinallyFlow, p); } + preFinallyPrior = finishFlowLabel(preFinallyFlow); } } @@ -1156,7 +1160,7 @@ namespace ts { // // extra edges that we inject allows to control this behavior // if when walking the flow we step on post-finally edge - we can mark matching pre-finally edge as locked so it will be skipped. - const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preTryFlow, lock: {} }; + const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preFinallyPrior, lock: {} }; addAntecedent(preFinallyLabel, preFinallyFlow); currentFlow = finishFlowLabel(preFinallyLabel); @@ -3137,8 +3141,8 @@ namespace ts { if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ObjectLiteralExpression) { // Destructuring object assignments with are ES2015 syntax - // and possibly ESNext if they contain rest - transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment; + // and possibly ES2018 if they contain rest + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment; } else if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ArrayLiteralExpression) { // Destructuring assignments are ES2015 syntax. @@ -3174,9 +3178,9 @@ namespace ts { transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.ContainsTypeScriptClassSyntax; } - // parameters with object rest destructuring are ES Next syntax + // parameters with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // If a parameter has an initializer, a binding pattern or a dotDotDot token, then @@ -3326,9 +3330,9 @@ namespace ts { transformFlags |= TransformFlags.AssertTypeScript; } - // function declarations with object rest destructuring are ES Next syntax + // function declarations with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } node.transformFlags = transformFlags | TransformFlags.HasComputedFlags; @@ -3350,14 +3354,14 @@ namespace ts { transformFlags |= TransformFlags.AssertTypeScript; } - // function declarations with object rest destructuring are ES Next syntax + // function declarations with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // An async method declaration is ES2017 syntax. if (hasModifier(node, ModifierFlags.Async)) { - transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017; + transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017; } if (node.asteriskToken) { @@ -3381,9 +3385,9 @@ namespace ts { transformFlags |= TransformFlags.AssertTypeScript; } - // function declarations with object rest destructuring are ES Next syntax + // function declarations with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } node.transformFlags = transformFlags | TransformFlags.HasComputedFlags; @@ -3427,12 +3431,12 @@ namespace ts { // An async function declaration is ES2017 syntax. if (modifierFlags & ModifierFlags.Async) { - transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017; + transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017; } - // function declarations with object rest destructuring are ES Next syntax + // function declarations with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // If a FunctionDeclaration's subtree has marked the container as needing to capture the @@ -3469,12 +3473,12 @@ namespace ts { // An async function expression is ES2017 syntax. if (hasModifier(node, ModifierFlags.Async)) { - transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017; + transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017; } - // function expressions with object rest destructuring are ES Next syntax + // function expressions with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } @@ -3513,9 +3517,9 @@ namespace ts { transformFlags |= TransformFlags.AssertES2017; } - // arrow functions with object rest destructuring are ES Next syntax + // arrow functions with object rest destructuring are ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // If an ArrowFunction contains a lexical this, its container must capture the lexical this. @@ -3535,8 +3539,8 @@ namespace ts { if (transformFlags & TransformFlags.Super) { transformFlags ^= TransformFlags.Super; // super inside of an async function requires hoisting the super access (ES2017). - // same for super inside of an async generator, which is ESNext. - transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsESNext; + // same for super inside of an async generator, which is ES2018. + transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsES2018; } node.transformFlags = transformFlags | TransformFlags.HasComputedFlags; @@ -3553,8 +3557,8 @@ namespace ts { if (expressionFlags & TransformFlags.Super) { transformFlags &= ~TransformFlags.Super; // super inside of an async function requires hoisting the super access (ES2017). - // same for super inside of an async generator, which is ESNext. - transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsESNext; + // same for super inside of an async generator, which is ES2018. + transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsES2018; } node.transformFlags = transformFlags | TransformFlags.HasComputedFlags; @@ -3565,9 +3569,9 @@ namespace ts { let transformFlags = subtreeFlags; transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern; - // A VariableDeclaration containing ObjectRest is ESNext syntax + // A VariableDeclaration containing ObjectRest is ES2018 syntax if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } // Type annotations are TypeScript syntax. @@ -3674,8 +3678,8 @@ namespace ts { switch (kind) { case SyntaxKind.AsyncKeyword: case SyntaxKind.AwaitExpression: - // async/await is ES2017 syntax, but may be ESNext syntax (for async generators) - transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2017; + // async/await is ES2017 syntax, but may be ES2018 syntax (for async generators) + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2017; break; case SyntaxKind.TypeAssertionExpression: @@ -3747,7 +3751,7 @@ namespace ts { case SyntaxKind.ForOfStatement: // This node is either ES2015 syntax or ES2017 syntax (if it is a for-await-of). if ((node).awaitModifier) { - transformFlags |= TransformFlags.AssertESNext; + transformFlags |= TransformFlags.AssertES2018; } transformFlags |= TransformFlags.AssertES2015; break; @@ -3755,7 +3759,7 @@ namespace ts { case SyntaxKind.YieldExpression: // This node is either ES2015 syntax (in a generator) or ES2017 syntax (in an async // generator). - transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.ContainsYield; + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2015 | TransformFlags.ContainsYield; break; case SyntaxKind.AnyKeyword: @@ -3824,7 +3828,7 @@ namespace ts { break; case SyntaxKind.SpreadAssignment: - transformFlags |= TransformFlags.AssertESNext | TransformFlags.ContainsObjectRestOrSpread; + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.ContainsObjectRestOrSpread; break; case SyntaxKind.SuperKeyword: @@ -3841,7 +3845,7 @@ namespace ts { case SyntaxKind.ObjectBindingPattern: transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern; if (subtreeFlags & TransformFlags.ContainsRestOrSpread) { - transformFlags |= TransformFlags.AssertESNext | TransformFlags.ContainsObjectRestOrSpread; + transformFlags |= TransformFlags.AssertES2018 | TransformFlags.ContainsObjectRestOrSpread; } excludeFlags = TransformFlags.BindingPatternExcludes; break; @@ -3879,8 +3883,8 @@ namespace ts { if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) { // If an ObjectLiteralExpression contains a spread element, then it - // is an ES next node. - transformFlags |= TransformFlags.AssertESNext; + // is an ES2018 node. + transformFlags |= TransformFlags.AssertES2018; } break; @@ -3915,8 +3919,8 @@ namespace ts { break; case SyntaxKind.ReturnStatement: - // Return statements may require an `await` in ESNext. - transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion | TransformFlags.AssertESNext; + // Return statements may require an `await` in ES2018. + transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion | TransformFlags.AssertES2018; break; case SyntaxKind.ContinueStatement: diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index ce06e84b2fd..f7cc72c534d 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1716,7 +1716,7 @@ namespace ts { } const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.Type & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined, /*isUse*/ false)); if (symbol && !(symbol.flags & SymbolFlags.NamespaceModule)) { - const message = (name === "Promise" || name === "Symbol") + const message = isES2015OrLaterConstructorName(name) ? Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later : Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here; error(errorLocation, message, unescapeLeadingUnderscores(name)); @@ -1726,6 +1726,19 @@ namespace ts { return false; } + function isES2015OrLaterConstructorName(n: __String) { + switch (n) { + case "Promise": + case "Symbol": + case "Map": + case "WeakMap": + case "Set": + case "WeakSet": + return true; + } + return false; + } + function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean { if (meaning & (SymbolFlags.Value & ~SymbolFlags.NamespaceModule & ~SymbolFlags.Type)) { const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.NamespaceModule & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined, /*isUse*/ false)); @@ -10841,7 +10854,7 @@ namespace ts { function getHomomorphicTypeVariable(type: MappedType) { const constraintType = getConstraintTypeFromMappedType(type); if (constraintType.flags & TypeFlags.Index) { - const typeVariable = (constraintType).type; + const typeVariable = getActualTypeVariable((constraintType).type); if (typeVariable.flags & TypeFlags.TypeParameter) { return typeVariable; } @@ -10864,26 +10877,15 @@ namespace ts { if (typeVariable) { const mappedTypeVariable = instantiateType(typeVariable, mapper); if (typeVariable !== mappedTypeVariable) { - // If we are already in the process of creating an instantiation of this mapped type, - // return the error type. This situation only arises if we are instantiating the mapped - // type for an array or tuple type, as we then need to eagerly resolve the (possibly - // circular) element type(s). - if (type.instantiating) { - return errorType; - } - type.instantiating = true; - const modifiers = getMappedTypeModifiers(type); - const result = mapType(mappedTypeVariable, t => { - if (t.flags & (TypeFlags.AnyOrUnknown | TypeFlags.InstantiableNonPrimitive | TypeFlags.Object | TypeFlags.Intersection) && t !== wildcardType) { + return mapType(mappedTypeVariable, t => { + if (t.flags & (TypeFlags.AnyOrUnknown | TypeFlags.InstantiableNonPrimitive | TypeFlags.Object | TypeFlags.Intersection) && t !== wildcardType && t !== errorType) { const replacementMapper = createReplacementMapper(typeVariable, t, mapper); - return isArrayType(t) ? createArrayType(instantiateMappedTypeTemplate(type, numberType, /*isOptional*/ true, replacementMapper), getModifiedReadonlyState(isReadonlyArrayType(t), modifiers)) : + return isArrayType(t) ? instantiateMappedArrayType(t, type, replacementMapper) : isTupleType(t) ? instantiateMappedTupleType(t, type, replacementMapper) : instantiateAnonymousType(type, replacementMapper); } return t; }); - type.instantiating = false; - return result; } } return instantiateAnonymousType(type, mapper); @@ -10893,6 +10895,12 @@ namespace ts { return modifiers & MappedTypeModifiers.IncludeReadonly ? true : modifiers & MappedTypeModifiers.ExcludeReadonly ? false : state; } + function instantiateMappedArrayType(arrayType: Type, mappedType: MappedType, mapper: TypeMapper) { + const elementType = instantiateMappedTypeTemplate(mappedType, numberType, /*isOptional*/ true, mapper); + return elementType === errorType ? errorType : + createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType))); + } + function instantiateMappedTupleType(tupleType: TupleTypeReference, mappedType: MappedType, mapper: TypeMapper) { const minLength = tupleType.target.minLength; const elementTypes = map(tupleType.typeArguments || emptyArray, (_, i) => @@ -10902,7 +10910,8 @@ namespace ts { modifiers & MappedTypeModifiers.ExcludeOptional ? getTypeReferenceArity(tupleType) - (tupleType.target.hasRestElement ? 1 : 0) : minLength; const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers); - return createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.associatedNames); + return contains(elementTypes, errorType) ? errorType : + createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.associatedNames); } function instantiateMappedTypeTemplate(type: MappedType, key: Type, isOptional: boolean, mapper: TypeMapper) { @@ -16151,13 +16160,37 @@ namespace ts { } function narrowTypeBySwitchOnDiscriminant(type: Type, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number) { - // We only narrow if all case expressions specify values with unit types + // We only narrow if all case expressions specify + // values with unit types, except for the case where + // `type` is unknown. In this instance we map object + // types to the nonPrimitive type and narrow with that. const switchTypes = getSwitchClauseTypes(switchStatement); if (!switchTypes.length) { return type; } const clauseTypes = switchTypes.slice(clauseStart, clauseEnd); const hasDefaultClause = clauseStart === clauseEnd || contains(clauseTypes, neverType); + if ((type.flags & TypeFlags.Unknown) && !hasDefaultClause) { + let groundClauseTypes: Type[] | undefined; + for (let i = 0; i < clauseTypes.length; i += 1) { + const t = clauseTypes[i]; + if (t.flags & (TypeFlags.Primitive | TypeFlags.NonPrimitive)) { + if (groundClauseTypes !== undefined) { + groundClauseTypes.push(t); + } + } + else if (t.flags & TypeFlags.Object) { + if (groundClauseTypes === undefined) { + groundClauseTypes = clauseTypes.slice(0, i); + } + groundClauseTypes.push(nonPrimitiveType); + } + else { + return type; + } + } + return getUnionType(groundClauseTypes === undefined ? clauseTypes : groundClauseTypes); + } const discriminantType = getUnionType(clauseTypes); const caseType = discriminantType.flags & TypeFlags.Never ? neverType : @@ -23265,24 +23298,36 @@ namespace ts { const uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple); const type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode); if (isConstEnumObjectType(type)) { - // enum object type for const enums are only permitted in: - // - 'left' in property access - // - 'object' in indexed access - // - target in rhs of import statement - const ok = - (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).expression === node) || - (node.parent.kind === SyntaxKind.ElementAccessExpression && (node.parent).expression === node) || - ((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(node) || - (node.parent.kind === SyntaxKind.TypeQuery && (node.parent).exprName === node)); - - if (!ok) { - error(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query); - } + checkConstEnumAccess(node, type); } currentNode = saveCurrentNode; return type; } + function checkConstEnumAccess(node: Expression | QualifiedName, type: Type) { + // enum object type for const enums are only permitted in: + // - 'left' in property access + // - 'object' in indexed access + // - target in rhs of import statement + const ok = + (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).expression === node) || + (node.parent.kind === SyntaxKind.ElementAccessExpression && (node.parent).expression === node) || + ((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(node) || + (node.parent.kind === SyntaxKind.TypeQuery && (node.parent).exprName === node)); + + if (!ok) { + error(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query); + } + + if (compilerOptions.isolatedModules) { + Debug.assert(!!(type.symbol.flags & SymbolFlags.ConstEnum)); + const constEnumDeclaration = type.symbol.valueDeclaration as EnumDeclaration; + if (constEnumDeclaration.flags & NodeFlags.Ambient) { + error(node, Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided); + } + } + } + function checkParenthesizedExpression(node: ParenthesizedExpression, checkMode?: CheckMode): Type { const tag = isInJSFile(node) ? getJSDocTypeTag(node) : undefined; if (tag) { @@ -27225,7 +27270,7 @@ namespace ts { reference.expression.parent = reference; reference.parent = constructor; reference.flowNode = constructor.returnFlowNode; - const flowType = getFlowTypeOfReference(reference, getOptionalType(propType)); + const flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType)); return !(getFalsyFlags(flowType) & TypeFlags.Undefined); } @@ -27460,11 +27505,6 @@ namespace ts { computeEnumMemberValues(node); - const enumIsConst = isEnumConst(node); - if (compilerOptions.isolatedModules && enumIsConst && node.flags & NodeFlags.Ambient) { - error(node.name, Diagnostics.Ambient_const_enums_are_not_allowed_when_the_isolatedModules_flag_is_provided); - } - // Spec 2014 - Section 9.3: // It isn't possible for one enum declaration to continue the automatic numbering sequence of another, // and when an enum type has multiple declarations, only one declaration is permitted to omit a value @@ -27475,6 +27515,7 @@ namespace ts { const firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind); if (node === firstDeclaration) { if (enumSymbol.declarations.length > 1) { + const enumIsConst = isEnumConst(node); // check that const is placed\omitted on all enum declarations forEach(enumSymbol.declarations, decl => { if (isEnumDeclaration(decl) && isEnumConst(decl) !== enumIsConst) { diff --git a/src/compiler/core.ts b/src/compiler/core.ts index a2f2b245502..eb24dd1edd5 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -1652,7 +1652,7 @@ namespace ts { } export function assertNever(member: never, message = "Illegal value:", stackCrawlMark?: AnyFunction): never { - const detail = "kind" in member && "pos" in member ? "SyntaxKind: " + showSyntaxKind(member as Node) : JSON.stringify(member); + const detail = typeof member === "object" && "kind" in member && "pos" in member ? "SyntaxKind: " + showSyntaxKind(member as Node) : JSON.stringify(member); return fail(`${message} ${detail}`, stackCrawlMark || assertNever); } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 094033cddca..f2f9ea23028 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -659,10 +659,6 @@ "category": "Error", "code": 1208 }, - "Ambient const enums are not allowed when the '--isolatedModules' flag is provided.": { - "category": "Error", - "code": 1209 - }, "Invalid use of '{0}'. Class definitions are automatically in strict mode.": { "category": "Error", "code": 1210 @@ -2581,6 +2577,10 @@ "category": "Error", "code": 2747 }, + "Cannot access ambient const enums when the '--isolatedModules' flag is provided.": { + "category": "Error", + "code": 2748 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts index 2ad6caf9896..601fb50f8b1 100644 --- a/src/compiler/factory.ts +++ b/src/compiler/factory.ts @@ -2629,7 +2629,7 @@ namespace ts { return node; } - let allUnscopedEmitHelpers: ReadonlyMap | undefined; + let allUnscopedEmitHelpers: ReadonlyMap | undefined; function getAllUnscopedEmitHelpers() { return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = arrayToMap([ valuesHelper, @@ -2668,7 +2668,7 @@ namespace ts { export function createUnparsedSourceFile(textOrInputFiles: string | InputFiles, mapPathOrType?: string, mapText?: string): UnparsedSource { const node = createUnparsedSource(); let prologues: UnparsedPrologue[] | undefined; - let helpers: UnscopedEmitHelpers[] | undefined; + let helpers: UnscopedEmitHelper[] | undefined; let referencedFiles: FileReference[] | undefined; let typeReferenceDirectives: string[] | undefined; let libReferenceDirectives: FileReference[] | undefined; @@ -3613,7 +3613,7 @@ namespace ts { return setEmitFlags(createIdentifier(name), EmitFlags.HelperName | EmitFlags.AdviseOnEmitNode); } - export const valuesHelper: UnscopedEmitHelpers = { + export const valuesHelper: UnscopedEmitHelper = { name: "typescript:values", scoped: false, text: ` @@ -3641,7 +3641,7 @@ namespace ts { ); } - export const readHelper: UnscopedEmitHelpers = { + export const readHelper: UnscopedEmitHelper = { name: "typescript:read", scoped: false, text: ` @@ -3677,7 +3677,7 @@ namespace ts { ); } - export const spreadHelper: UnscopedEmitHelpers = { + export const spreadHelper: UnscopedEmitHelper = { name: "typescript:spread", scoped: false, text: ` diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts index fdcaadb4040..aabc6be57a0 100644 --- a/src/compiler/transformer.ts +++ b/src/compiler/transformer.ts @@ -42,6 +42,10 @@ namespace ts { transformers.push(transformESNext); } + if (languageVersion < ScriptTarget.ES2018) { + transformers.push(transformES2018); + } + if (languageVersion < ScriptTarget.ES2017) { transformers.push(transformES2017); } diff --git a/src/compiler/transformers/destructuring.ts b/src/compiler/transformers/destructuring.ts index ac72fe981ef..b5e829ee683 100644 --- a/src/compiler/transformers/destructuring.ts +++ b/src/compiler/transformers/destructuring.ts @@ -512,7 +512,7 @@ namespace ts { return name; } - export const restHelper: UnscopedEmitHelpers = { + export const restHelper: UnscopedEmitHelper = { name: "typescript:rest", scoped: false, text: ` diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts index 53857a53a39..64d58da4ba6 100644 --- a/src/compiler/transformers/es2015.ts +++ b/src/compiler/transformers/es2015.ts @@ -4383,7 +4383,7 @@ namespace ts { ); } - export const extendsHelper: UnscopedEmitHelpers = { + export const extendsHelper: UnscopedEmitHelper = { name: "typescript:extends", scoped: false, priority: 0, @@ -4404,7 +4404,7 @@ namespace ts { })();` }; - export const templateObjectHelper: UnscopedEmitHelpers = { + export const templateObjectHelper: UnscopedEmitHelper = { name: "typescript:makeTemplateObject", scoped: false, priority: 0, diff --git a/src/compiler/transformers/es2017.ts b/src/compiler/transformers/es2017.ts index 7a4bab756d8..1b4252bc9f8 100644 --- a/src/compiler/transformers/es2017.ts +++ b/src/compiler/transformers/es2017.ts @@ -750,7 +750,7 @@ namespace ts { NodeFlags.Const)); } - export const awaiterHelper: UnscopedEmitHelpers = { + export const awaiterHelper: UnscopedEmitHelper = { name: "typescript:awaiter", scoped: false, priority: 5, diff --git a/src/compiler/transformers/es2018.ts b/src/compiler/transformers/es2018.ts new file mode 100644 index 00000000000..fd7f9d325c7 --- /dev/null +++ b/src/compiler/transformers/es2018.ts @@ -0,0 +1,1046 @@ +/*@internal*/ +namespace ts { + const enum ESNextSubstitutionFlags { + /** Enables substitutions for async methods with `super` calls. */ + AsyncMethodsWithSuper = 1 << 0 + } + + export function transformES2018(context: TransformationContext) { + const { + resumeLexicalEnvironment, + endLexicalEnvironment, + hoistVariableDeclaration + } = context; + + const resolver = context.getEmitResolver(); + const compilerOptions = context.getCompilerOptions(); + const languageVersion = getEmitScriptTarget(compilerOptions); + + const previousOnEmitNode = context.onEmitNode; + context.onEmitNode = onEmitNode; + + const previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + + let enabledSubstitutions: ESNextSubstitutionFlags; + let enclosingFunctionFlags: FunctionFlags; + let enclosingSuperContainerFlags: NodeCheckFlags = 0; + + /** Keeps track of property names accessed on super (`super.x`) within async functions. */ + let capturedSuperProperties: UnderscoreEscapedMap; + /** Whether the async function contains an element access on super (`super[x]`). */ + let hasSuperElementAccess: boolean; + /** A set of node IDs for generated super accessors. */ + const substitutedSuperAccessors: boolean[] = []; + + return chainBundle(transformSourceFile); + + function transformSourceFile(node: SourceFile) { + if (node.isDeclarationFile) { + return node; + } + + const visited = visitEachChild(node, visitor, context); + addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + + function visitor(node: Node): VisitResult { + return visitorWorker(node, /*noDestructuringValue*/ false); + } + + function visitorNoDestructuringValue(node: Node): VisitResult { + return visitorWorker(node, /*noDestructuringValue*/ true); + } + + function visitorNoAsyncModifier(node: Node): VisitResult { + if (node.kind === SyntaxKind.AsyncKeyword) { + return undefined; + } + return node; + } + + function visitorWorker(node: Node, noDestructuringValue: boolean): VisitResult { + if ((node.transformFlags & TransformFlags.ContainsES2018) === 0) { + return node; + } + switch (node.kind) { + case SyntaxKind.AwaitExpression: + return visitAwaitExpression(node as AwaitExpression); + case SyntaxKind.YieldExpression: + return visitYieldExpression(node as YieldExpression); + case SyntaxKind.ReturnStatement: + return visitReturnStatement(node as ReturnStatement); + case SyntaxKind.LabeledStatement: + return visitLabeledStatement(node as LabeledStatement); + case SyntaxKind.ObjectLiteralExpression: + return visitObjectLiteralExpression(node as ObjectLiteralExpression); + case SyntaxKind.BinaryExpression: + return visitBinaryExpression(node as BinaryExpression, noDestructuringValue); + case SyntaxKind.VariableDeclaration: + return visitVariableDeclaration(node as VariableDeclaration); + case SyntaxKind.ForOfStatement: + return visitForOfStatement(node as ForOfStatement, /*outermostLabeledStatement*/ undefined); + case SyntaxKind.ForStatement: + return visitForStatement(node as ForStatement); + case SyntaxKind.VoidExpression: + return visitVoidExpression(node as VoidExpression); + case SyntaxKind.Constructor: + return visitConstructorDeclaration(node as ConstructorDeclaration); + case SyntaxKind.MethodDeclaration: + return visitMethodDeclaration(node as MethodDeclaration); + case SyntaxKind.GetAccessor: + return visitGetAccessorDeclaration(node as GetAccessorDeclaration); + case SyntaxKind.SetAccessor: + return visitSetAccessorDeclaration(node as SetAccessorDeclaration); + case SyntaxKind.FunctionDeclaration: + return visitFunctionDeclaration(node as FunctionDeclaration); + case SyntaxKind.FunctionExpression: + return visitFunctionExpression(node as FunctionExpression); + case SyntaxKind.ArrowFunction: + return visitArrowFunction(node as ArrowFunction); + case SyntaxKind.Parameter: + return visitParameter(node as ParameterDeclaration); + case SyntaxKind.ExpressionStatement: + return visitExpressionStatement(node as ExpressionStatement); + case SyntaxKind.ParenthesizedExpression: + return visitParenthesizedExpression(node as ParenthesizedExpression, noDestructuringValue); + case SyntaxKind.PropertyAccessExpression: + if (capturedSuperProperties && isPropertyAccessExpression(node) && node.expression.kind === SyntaxKind.SuperKeyword) { + capturedSuperProperties.set(node.name.escapedText, true); + } + return visitEachChild(node, visitor, context); + case SyntaxKind.ElementAccessExpression: + if (capturedSuperProperties && (node).expression.kind === SyntaxKind.SuperKeyword) { + hasSuperElementAccess = true; + } + return visitEachChild(node, visitor, context); + default: + return visitEachChild(node, visitor, context); + } + } + + function visitAwaitExpression(node: AwaitExpression): Expression { + if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { + return setOriginalNode( + setTextRange( + createYield(createAwaitHelper(context, visitNode(node.expression, visitor, isExpression))), + /*location*/ node + ), + node + ); + } + return visitEachChild(node, visitor, context); + } + + function visitYieldExpression(node: YieldExpression) { + if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { + if (node.asteriskToken) { + const expression = visitNode(node.expression, visitor, isExpression); + + return setOriginalNode( + setTextRange( + createYield( + createAwaitHelper(context, + updateYield( + node, + node.asteriskToken, + createAsyncDelegatorHelper( + context, + createAsyncValuesHelper(context, expression, expression), + expression + ) + ) + ) + ), + node + ), + node + ); + } + + return setOriginalNode( + setTextRange( + createYield( + createDownlevelAwait( + node.expression + ? visitNode(node.expression, visitor, isExpression) + : createVoidZero() + ) + ), + node + ), + node + ); + } + + return visitEachChild(node, visitor, context); + } + + function visitReturnStatement(node: ReturnStatement) { + if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { + return updateReturn(node, createDownlevelAwait( + node.expression ? visitNode(node.expression, visitor, isExpression) : createVoidZero() + )); + } + + return visitEachChild(node, visitor, context); + } + + function visitLabeledStatement(node: LabeledStatement) { + if (enclosingFunctionFlags & FunctionFlags.Async) { + const statement = unwrapInnermostStatementOfLabel(node); + if (statement.kind === SyntaxKind.ForOfStatement && (statement).awaitModifier) { + return visitForOfStatement(statement, node); + } + return restoreEnclosingLabel(visitEachChild(statement, visitor, context), node); + } + return visitEachChild(node, visitor, context); + } + + function chunkObjectLiteralElements(elements: ReadonlyArray): Expression[] { + let chunkObject: ObjectLiteralElementLike[] | undefined; + const objects: Expression[] = []; + for (const e of elements) { + if (e.kind === SyntaxKind.SpreadAssignment) { + if (chunkObject) { + objects.push(createObjectLiteral(chunkObject)); + chunkObject = undefined; + } + const target = e.expression; + objects.push(visitNode(target, visitor, isExpression)); + } + else { + chunkObject = append(chunkObject, e.kind === SyntaxKind.PropertyAssignment + ? createPropertyAssignment(e.name, visitNode(e.initializer, visitor, isExpression)) + : visitNode(e, visitor, isObjectLiteralElementLike)); + } + } + if (chunkObject) { + objects.push(createObjectLiteral(chunkObject)); + } + + return objects; + } + + function visitObjectLiteralExpression(node: ObjectLiteralExpression): Expression { + if (node.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + // spread elements emit like so: + // non-spread elements are chunked together into object literals, and then all are passed to __assign: + // { a, ...o, b } => __assign({a}, o, {b}); + // If the first element is a spread element, then the first argument to __assign is {}: + // { ...o, a, b, ...o2 } => __assign({}, o, {a, b}, o2) + const objects = chunkObjectLiteralElements(node.properties); + if (objects.length && objects[0].kind !== SyntaxKind.ObjectLiteralExpression) { + objects.unshift(createObjectLiteral()); + } + return createAssignHelper(context, objects); + } + return visitEachChild(node, visitor, context); + } + + function visitExpressionStatement(node: ExpressionStatement): ExpressionStatement { + return visitEachChild(node, visitorNoDestructuringValue, context); + } + + function visitParenthesizedExpression(node: ParenthesizedExpression, noDestructuringValue: boolean): ParenthesizedExpression { + return visitEachChild(node, noDestructuringValue ? visitorNoDestructuringValue : visitor, context); + } + + /** + * Visits a BinaryExpression that contains a destructuring assignment. + * + * @param node A BinaryExpression node. + */ + function visitBinaryExpression(node: BinaryExpression, noDestructuringValue: boolean): Expression { + if (isDestructuringAssignment(node) && node.left.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + return flattenDestructuringAssignment( + node, + visitor, + context, + FlattenLevel.ObjectRest, + !noDestructuringValue + ); + } + else if (node.operatorToken.kind === SyntaxKind.CommaToken) { + return updateBinary( + node, + visitNode(node.left, visitorNoDestructuringValue, isExpression), + visitNode(node.right, noDestructuringValue ? visitorNoDestructuringValue : visitor, isExpression) + ); + } + return visitEachChild(node, visitor, context); + } + + /** + * Visits a VariableDeclaration node with a binding pattern. + * + * @param node A VariableDeclaration node. + */ + function visitVariableDeclaration(node: VariableDeclaration): VisitResult { + // If we are here it is because the name contains a binding pattern with a rest somewhere in it. + if (isBindingPattern(node.name) && node.name.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + return flattenDestructuringBinding( + node, + visitor, + context, + FlattenLevel.ObjectRest + ); + } + return visitEachChild(node, visitor, context); + } + + function visitForStatement(node: ForStatement): VisitResult { + return updateFor( + node, + visitNode(node.initializer, visitorNoDestructuringValue, isForInitializer), + visitNode(node.condition, visitor, isExpression), + visitNode(node.incrementor, visitor, isExpression), + visitNode(node.statement, visitor, isStatement) + ); + } + + function visitVoidExpression(node: VoidExpression) { + return visitEachChild(node, visitorNoDestructuringValue, context); + } + + /** + * Visits a ForOfStatement and converts it into a ES2015-compatible ForOfStatement. + * + * @param node A ForOfStatement. + */ + function visitForOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement | undefined): VisitResult { + if (node.initializer.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + node = transformForOfStatementWithObjectRest(node); + } + if (node.awaitModifier) { + return transformForAwaitOfStatement(node, outermostLabeledStatement); + } + else { + return restoreEnclosingLabel(visitEachChild(node, visitor, context), outermostLabeledStatement); + } + } + + function transformForOfStatementWithObjectRest(node: ForOfStatement) { + const initializerWithoutParens = skipParentheses(node.initializer) as ForInitializer; + if (isVariableDeclarationList(initializerWithoutParens) || isAssignmentPattern(initializerWithoutParens)) { + let bodyLocation: TextRange | undefined; + let statementsLocation: TextRange | undefined; + const temp = createTempVariable(/*recordTempVariable*/ undefined); + const statements: Statement[] = [createForOfBindingStatement(initializerWithoutParens, temp)]; + if (isBlock(node.statement)) { + addRange(statements, node.statement.statements); + bodyLocation = node.statement; + statementsLocation = node.statement.statements; + } + else if (node.statement) { + append(statements, node.statement); + bodyLocation = node.statement; + statementsLocation = node.statement; + } + return updateForOf( + node, + node.awaitModifier, + setTextRange( + createVariableDeclarationList( + [ + setTextRange(createVariableDeclaration(temp), node.initializer) + ], + NodeFlags.Let + ), + node.initializer + ), + node.expression, + setTextRange( + createBlock( + setTextRange(createNodeArray(statements), statementsLocation), + /*multiLine*/ true + ), + bodyLocation + ) + ); + } + return node; + } + + function convertForOfStatementHead(node: ForOfStatement, boundValue: Expression) { + const binding = createForOfBindingStatement(node.initializer, boundValue); + + let bodyLocation: TextRange | undefined; + let statementsLocation: TextRange | undefined; + const statements: Statement[] = [visitNode(binding, visitor, isStatement)]; + const statement = visitNode(node.statement, visitor, isStatement); + if (isBlock(statement)) { + addRange(statements, statement.statements); + bodyLocation = statement; + statementsLocation = statement.statements; + } + else { + statements.push(statement); + } + + return setEmitFlags( + setTextRange( + createBlock( + setTextRange(createNodeArray(statements), statementsLocation), + /*multiLine*/ true + ), + bodyLocation + ), + EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps + ); + } + + function createDownlevelAwait(expression: Expression) { + return enclosingFunctionFlags & FunctionFlags.Generator + ? createYield(/*asteriskToken*/ undefined, createAwaitHelper(context, expression)) + : createAwait(expression); + } + + function transformForAwaitOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement | undefined) { + const expression = visitNode(node.expression, visitor, isExpression); + const iterator = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined); + const result = isIdentifier(expression) ? getGeneratedNameForNode(iterator) : createTempVariable(/*recordTempVariable*/ undefined); + const errorRecord = createUniqueName("e"); + const catchVariable = getGeneratedNameForNode(errorRecord); + const returnMethod = createTempVariable(/*recordTempVariable*/ undefined); + const callValues = createAsyncValuesHelper(context, expression, /*location*/ node.expression); + const callNext = createCall(createPropertyAccess(iterator, "next"), /*typeArguments*/ undefined, []); + const getDone = createPropertyAccess(result, "done"); + const getValue = createPropertyAccess(result, "value"); + const callReturn = createFunctionCall(returnMethod, iterator, []); + + hoistVariableDeclaration(errorRecord); + hoistVariableDeclaration(returnMethod); + + const forStatement = setEmitFlags( + setTextRange( + createFor( + /*initializer*/ setEmitFlags( + setTextRange( + createVariableDeclarationList([ + setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, callValues), node.expression), + createVariableDeclaration(result) + ]), + node.expression + ), + EmitFlags.NoHoisting + ), + /*condition*/ createComma( + createAssignment(result, createDownlevelAwait(callNext)), + createLogicalNot(getDone) + ), + /*incrementor*/ undefined, + /*statement*/ convertForOfStatementHead(node, getValue) + ), + /*location*/ node + ), + EmitFlags.NoTokenTrailingSourceMaps + ); + + return createTry( + createBlock([ + restoreEnclosingLabel( + forStatement, + outermostLabeledStatement + ) + ]), + createCatchClause( + createVariableDeclaration(catchVariable), + setEmitFlags( + createBlock([ + createExpressionStatement( + createAssignment( + errorRecord, + createObjectLiteral([ + createPropertyAssignment("error", catchVariable) + ]) + ) + ) + ]), + EmitFlags.SingleLine + ) + ), + createBlock([ + createTry( + /*tryBlock*/ createBlock([ + setEmitFlags( + createIf( + createLogicalAnd( + createLogicalAnd( + result, + createLogicalNot(getDone) + ), + createAssignment( + returnMethod, + createPropertyAccess(iterator, "return") + ) + ), + createExpressionStatement(createDownlevelAwait(callReturn)) + ), + EmitFlags.SingleLine + ) + ]), + /*catchClause*/ undefined, + /*finallyBlock*/ setEmitFlags( + createBlock([ + setEmitFlags( + createIf( + errorRecord, + createThrow( + createPropertyAccess(errorRecord, "error") + ) + ), + EmitFlags.SingleLine + ) + ]), + EmitFlags.SingleLine + ) + ) + ]) + ); + } + + function visitParameter(node: ParameterDeclaration): ParameterDeclaration { + if (node.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + // Binding patterns are converted into a generated name and are + // evaluated inside the function body. + return updateParameter( + node, + /*decorators*/ undefined, + /*modifiers*/ undefined, + node.dotDotDotToken, + getGeneratedNameForNode(node), + /*questionToken*/ undefined, + /*type*/ undefined, + visitNode(node.initializer, visitor, isExpression) + ); + } + return visitEachChild(node, visitor, context); + } + + function visitConstructorDeclaration(node: ConstructorDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = FunctionFlags.Normal; + const updated = updateConstructor( + node, + /*decorators*/ undefined, + node.modifiers, + visitParameterList(node.parameters, visitor, context), + transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitGetAccessorDeclaration(node: GetAccessorDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = FunctionFlags.Normal; + const updated = updateGetAccessor( + node, + /*decorators*/ undefined, + node.modifiers, + visitNode(node.name, visitor, isPropertyName), + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitSetAccessorDeclaration(node: SetAccessorDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = FunctionFlags.Normal; + const updated = updateSetAccessor( + node, + /*decorators*/ undefined, + node.modifiers, + visitNode(node.name, visitor, isPropertyName), + visitParameterList(node.parameters, visitor, context), + transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitMethodDeclaration(node: MethodDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateMethod( + node, + /*decorators*/ undefined, + enclosingFunctionFlags & FunctionFlags.Generator + ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) + : node.modifiers, + enclosingFunctionFlags & FunctionFlags.Async + ? undefined + : node.asteriskToken, + visitNode(node.name, visitor, isPropertyName), + visitNode>(/*questionToken*/ undefined, visitor, isToken), + /*typeParameters*/ undefined, + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitFunctionDeclaration(node: FunctionDeclaration) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateFunctionDeclaration( + node, + /*decorators*/ undefined, + enclosingFunctionFlags & FunctionFlags.Generator + ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) + : node.modifiers, + enclosingFunctionFlags & FunctionFlags.Async + ? undefined + : node.asteriskToken, + node.name, + /*typeParameters*/ undefined, + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitArrowFunction(node: ArrowFunction) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateArrowFunction( + node, + node.modifiers, + /*typeParameters*/ undefined, + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + node.equalsGreaterThanToken, + transformFunctionBody(node), + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function visitFunctionExpression(node: FunctionExpression) { + const savedEnclosingFunctionFlags = enclosingFunctionFlags; + enclosingFunctionFlags = getFunctionFlags(node); + const updated = updateFunctionExpression( + node, + enclosingFunctionFlags & FunctionFlags.Generator + ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) + : node.modifiers, + enclosingFunctionFlags & FunctionFlags.Async + ? undefined + : node.asteriskToken, + node.name, + /*typeParameters*/ undefined, + visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, + enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node) + ); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + return updated; + } + + function transformAsyncGeneratorFunctionBody(node: MethodDeclaration | AccessorDeclaration | FunctionDeclaration | FunctionExpression): FunctionBody { + resumeLexicalEnvironment(); + const statements: Statement[] = []; + const statementOffset = addPrologue(statements, node.body!.statements, /*ensureUseStrict*/ false, visitor); + appendObjectRestAssignmentsIfNeeded(statements, node); + + const savedCapturedSuperProperties = capturedSuperProperties; + const savedHasSuperElementAccess = hasSuperElementAccess; + capturedSuperProperties = createUnderscoreEscapedMap(); + hasSuperElementAccess = false; + + const returnStatement = createReturn( + createAsyncGeneratorHelper( + context, + createFunctionExpression( + /*modifiers*/ undefined, + createToken(SyntaxKind.AsteriskToken), + node.name && getGeneratedNameForNode(node.name), + /*typeParameters*/ undefined, + /*parameters*/ [], + /*type*/ undefined, + updateBlock( + node.body!, + visitLexicalEnvironment(node.body!.statements, visitor, context, statementOffset) + ) + ) + ) + ); + + // Minor optimization, emit `_super` helper to capture `super` access in an arrow. + // This step isn't needed if we eventually transform this to ES5. + const emitSuperHelpers = languageVersion >= ScriptTarget.ES2015 && resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuperBinding | NodeCheckFlags.AsyncMethodWithSuper); + + if (emitSuperHelpers) { + enableSubstitutionForAsyncMethodsWithSuper(); + const variableStatement = createSuperAccessVariableStatement(resolver, node, capturedSuperProperties); + substitutedSuperAccessors[getNodeId(variableStatement)] = true; + addStatementsAfterPrologue(statements, [variableStatement]); + } + + statements.push(returnStatement); + + addStatementsAfterPrologue(statements, endLexicalEnvironment()); + const block = updateBlock(node.body!, statements); + + if (emitSuperHelpers && hasSuperElementAccess) { + if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuperBinding) { + addEmitHelper(block, advancedAsyncSuperHelper); + } + else if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuper) { + addEmitHelper(block, asyncSuperHelper); + } + } + + capturedSuperProperties = savedCapturedSuperProperties; + hasSuperElementAccess = savedHasSuperElementAccess; + + return block; + } + + function transformFunctionBody(node: FunctionDeclaration | FunctionExpression | ConstructorDeclaration | MethodDeclaration | AccessorDeclaration): FunctionBody; + function transformFunctionBody(node: ArrowFunction): ConciseBody; + function transformFunctionBody(node: FunctionLikeDeclaration): ConciseBody { + resumeLexicalEnvironment(); + let statementOffset = 0; + const statements: Statement[] = []; + const body = visitNode(node.body, visitor, isConciseBody); + if (isBlock(body)) { + statementOffset = addPrologue(statements, body.statements, /*ensureUseStrict*/ false, visitor); + } + addRange(statements, appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node)); + const leadingStatements = endLexicalEnvironment(); + if (statementOffset > 0 || some(statements) || some(leadingStatements)) { + const block = convertToFunctionBody(body, /*multiLine*/ true); + addStatementsAfterPrologue(statements, leadingStatements); + addRange(statements, block.statements.slice(statementOffset)); + return updateBlock(block, setTextRange(createNodeArray(statements), block.statements)); + } + return body; + } + + function appendObjectRestAssignmentsIfNeeded(statements: Statement[] | undefined, node: FunctionLikeDeclaration): Statement[] | undefined { + for (const parameter of node.parameters) { + if (parameter.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { + const temp = getGeneratedNameForNode(parameter); + const declarations = flattenDestructuringBinding( + parameter, + visitor, + context, + FlattenLevel.ObjectRest, + temp, + /*doNotRecordTempVariablesInLine*/ false, + /*skipInitializer*/ true, + ); + if (some(declarations)) { + const statement = createVariableStatement( + /*modifiers*/ undefined, + createVariableDeclarationList( + declarations + ) + ); + setEmitFlags(statement, EmitFlags.CustomPrologue); + statements = append(statements, statement); + } + } + } + return statements; + } + + function enableSubstitutionForAsyncMethodsWithSuper() { + if ((enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper) === 0) { + enabledSubstitutions |= ESNextSubstitutionFlags.AsyncMethodsWithSuper; + + // We need to enable substitutions for call, property access, and element access + // if we need to rewrite super calls. + context.enableSubstitution(SyntaxKind.CallExpression); + context.enableSubstitution(SyntaxKind.PropertyAccessExpression); + context.enableSubstitution(SyntaxKind.ElementAccessExpression); + + // We need to be notified when entering and exiting declarations that bind super. + context.enableEmitNotification(SyntaxKind.ClassDeclaration); + context.enableEmitNotification(SyntaxKind.MethodDeclaration); + context.enableEmitNotification(SyntaxKind.GetAccessor); + context.enableEmitNotification(SyntaxKind.SetAccessor); + context.enableEmitNotification(SyntaxKind.Constructor); + // We need to be notified when entering the generated accessor arrow functions. + context.enableEmitNotification(SyntaxKind.VariableStatement); + } + } + + /** + * Called by the printer just before a node is printed. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to be printed. + * @param emitCallback The callback used to emit the node. + */ + function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) { + // If we need to support substitutions for `super` in an async method, + // we should track it here. + if (enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) { + const superContainerFlags = resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding); + if (superContainerFlags !== enclosingSuperContainerFlags) { + const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = superContainerFlags; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + } + // Disable substitution in the generated super accessor itself. + else if (enabledSubstitutions && substitutedSuperAccessors[getNodeId(node)]) { + const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = 0 as NodeCheckFlags; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + + previousOnEmitNode(hint, node, emitCallback); + } + + /** + * Hooks node substitutions. + * + * @param hint The context for the emitter. + * @param node The node to substitute. + */ + function onSubstituteNode(hint: EmitHint, node: Node) { + node = previousOnSubstituteNode(hint, node); + if (hint === EmitHint.Expression && enclosingSuperContainerFlags) { + return substituteExpression(node); + } + return node; + } + + function substituteExpression(node: Expression) { + switch (node.kind) { + case SyntaxKind.PropertyAccessExpression: + return substitutePropertyAccessExpression(node); + case SyntaxKind.ElementAccessExpression: + return substituteElementAccessExpression(node); + case SyntaxKind.CallExpression: + return substituteCallExpression(node); + } + return node; + } + + function substitutePropertyAccessExpression(node: PropertyAccessExpression) { + if (node.expression.kind === SyntaxKind.SuperKeyword) { + return setTextRange( + createPropertyAccess( + createFileLevelUniqueName("_super"), + node.name), + node + ); + } + return node; + } + + function substituteElementAccessExpression(node: ElementAccessExpression) { + if (node.expression.kind === SyntaxKind.SuperKeyword) { + return createSuperElementAccessInAsyncMethod( + node.argumentExpression, + node + ); + } + return node; + } + + function substituteCallExpression(node: CallExpression): Expression { + const expression = node.expression; + if (isSuperProperty(expression)) { + const argumentExpression = isPropertyAccessExpression(expression) + ? substitutePropertyAccessExpression(expression) + : substituteElementAccessExpression(expression); + return createCall( + createPropertyAccess(argumentExpression, "call"), + /*typeArguments*/ undefined, + [ + createThis(), + ...node.arguments + ] + ); + } + return node; + } + + function isSuperContainer(node: Node) { + const kind = node.kind; + return kind === SyntaxKind.ClassDeclaration + || kind === SyntaxKind.Constructor + || kind === SyntaxKind.MethodDeclaration + || kind === SyntaxKind.GetAccessor + || kind === SyntaxKind.SetAccessor; + } + + function createSuperElementAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression { + if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) { + return setTextRange( + createPropertyAccess( + createCall( + createIdentifier("_superIndex"), + /*typeArguments*/ undefined, + [argumentExpression] + ), + "value" + ), + location + ); + } + else { + return setTextRange( + createCall( + createIdentifier("_superIndex"), + /*typeArguments*/ undefined, + [argumentExpression] + ), + location + ); + } + } + } + + export const assignHelper: UnscopedEmitHelper = { + name: "typescript:assign", + scoped: false, + priority: 1, + text: ` + var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); + };` + }; + + export function createAssignHelper(context: TransformationContext, attributesSegments: Expression[]) { + if (context.getCompilerOptions().target! >= ScriptTarget.ES2015) { + return createCall(createPropertyAccess(createIdentifier("Object"), "assign"), + /*typeArguments*/ undefined, + attributesSegments); + } + context.requestEmitHelper(assignHelper); + return createCall( + getHelperName("__assign"), + /*typeArguments*/ undefined, + attributesSegments + ); + } + + export const awaitHelper: UnscopedEmitHelper = { + name: "typescript:await", + scoped: false, + text: ` + var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }` + }; + + function createAwaitHelper(context: TransformationContext, expression: Expression) { + context.requestEmitHelper(awaitHelper); + return createCall(getHelperName("__await"), /*typeArguments*/ undefined, [expression]); + } + + export const asyncGeneratorHelper: UnscopedEmitHelper = { + name: "typescript:asyncGenerator", + scoped: false, + text: ` + var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } + };` + }; + + function createAsyncGeneratorHelper(context: TransformationContext, generatorFunc: FunctionExpression) { + context.requestEmitHelper(awaitHelper); + context.requestEmitHelper(asyncGeneratorHelper); + + // Mark this node as originally an async function + (generatorFunc.emitNode || (generatorFunc.emitNode = {} as EmitNode)).flags |= EmitFlags.AsyncFunctionBody; + + return createCall( + getHelperName("__asyncGenerator"), + /*typeArguments*/ undefined, + [ + createThis(), + createIdentifier("arguments"), + generatorFunc + ] + ); + } + + export const asyncDelegator: UnscopedEmitHelper = { + name: "typescript:asyncDelegator", + scoped: false, + text: ` + var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { + var i, p; + return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; } + };` + }; + + function createAsyncDelegatorHelper(context: TransformationContext, expression: Expression, location?: TextRange) { + context.requestEmitHelper(awaitHelper); + context.requestEmitHelper(asyncDelegator); + return setTextRange( + createCall( + getHelperName("__asyncDelegator"), + /*typeArguments*/ undefined, + [expression] + ), + location + ); + } + + export const asyncValues: UnscopedEmitHelper = { + name: "typescript:asyncValues", + scoped: false, + text: ` + var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } + };` + }; + + function createAsyncValuesHelper(context: TransformationContext, expression: Expression, location?: TextRange) { + context.requestEmitHelper(asyncValues); + return setTextRange( + createCall( + getHelperName("__asyncValues"), + /*typeArguments*/ undefined, + [expression] + ), + location + ); + } +} diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index e174cf2f7a0..7c20d39cdea 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -1,38 +1,6 @@ /*@internal*/ namespace ts { - const enum ESNextSubstitutionFlags { - /** Enables substitutions for async methods with `super` calls. */ - AsyncMethodsWithSuper = 1 << 0 - } - export function transformESNext(context: TransformationContext) { - const { - resumeLexicalEnvironment, - endLexicalEnvironment, - hoistVariableDeclaration - } = context; - - const resolver = context.getEmitResolver(); - const compilerOptions = context.getCompilerOptions(); - const languageVersion = getEmitScriptTarget(compilerOptions); - - const previousOnEmitNode = context.onEmitNode; - context.onEmitNode = onEmitNode; - - const previousOnSubstituteNode = context.onSubstituteNode; - context.onSubstituteNode = onSubstituteNode; - - let enabledSubstitutions: ESNextSubstitutionFlags; - let enclosingFunctionFlags: FunctionFlags; - let enclosingSuperContainerFlags: NodeCheckFlags = 0; - - /** Keeps track of property names accessed on super (`super.x`) within async functions. */ - let capturedSuperProperties: UnderscoreEscapedMap; - /** Whether the async function contains an element access on super (`super[x]`). */ - let hasSuperElementAccess: boolean; - /** A set of node IDs for generated super accessors. */ - const substitutedSuperAccessors: boolean[] = []; - return chainBundle(transformSourceFile); function transformSourceFile(node: SourceFile) { @@ -40,215 +8,21 @@ namespace ts { return node; } - const visited = visitEachChild(node, visitor, context); - addEmitHelpers(visited, context.readEmitHelpers()); - return visited; + return visitEachChild(node, visitor, context); } function visitor(node: Node): VisitResult { - return visitorWorker(node, /*noDestructuringValue*/ false); - } - - function visitorNoDestructuringValue(node: Node): VisitResult { - return visitorWorker(node, /*noDestructuringValue*/ true); - } - - function visitorNoAsyncModifier(node: Node): VisitResult { - if (node.kind === SyntaxKind.AsyncKeyword) { - return undefined; - } - return node; - } - - function visitorWorker(node: Node, noDestructuringValue: boolean): VisitResult { if ((node.transformFlags & TransformFlags.ContainsESNext) === 0) { return node; } switch (node.kind) { - case SyntaxKind.AwaitExpression: - return visitAwaitExpression(node as AwaitExpression); - case SyntaxKind.YieldExpression: - return visitYieldExpression(node as YieldExpression); - case SyntaxKind.ReturnStatement: - return visitReturnStatement(node as ReturnStatement); - case SyntaxKind.LabeledStatement: - return visitLabeledStatement(node as LabeledStatement); - case SyntaxKind.ObjectLiteralExpression: - return visitObjectLiteralExpression(node as ObjectLiteralExpression); - case SyntaxKind.BinaryExpression: - return visitBinaryExpression(node as BinaryExpression, noDestructuringValue); - case SyntaxKind.VariableDeclaration: - return visitVariableDeclaration(node as VariableDeclaration); - case SyntaxKind.ForOfStatement: - return visitForOfStatement(node as ForOfStatement, /*outermostLabeledStatement*/ undefined); - case SyntaxKind.ForStatement: - return visitForStatement(node as ForStatement); - case SyntaxKind.VoidExpression: - return visitVoidExpression(node as VoidExpression); - case SyntaxKind.Constructor: - return visitConstructorDeclaration(node as ConstructorDeclaration); - case SyntaxKind.MethodDeclaration: - return visitMethodDeclaration(node as MethodDeclaration); - case SyntaxKind.GetAccessor: - return visitGetAccessorDeclaration(node as GetAccessorDeclaration); - case SyntaxKind.SetAccessor: - return visitSetAccessorDeclaration(node as SetAccessorDeclaration); - case SyntaxKind.FunctionDeclaration: - return visitFunctionDeclaration(node as FunctionDeclaration); - case SyntaxKind.FunctionExpression: - return visitFunctionExpression(node as FunctionExpression); - case SyntaxKind.ArrowFunction: - return visitArrowFunction(node as ArrowFunction); - case SyntaxKind.Parameter: - return visitParameter(node as ParameterDeclaration); - case SyntaxKind.ExpressionStatement: - return visitExpressionStatement(node as ExpressionStatement); - case SyntaxKind.ParenthesizedExpression: - return visitParenthesizedExpression(node as ParenthesizedExpression, noDestructuringValue); case SyntaxKind.CatchClause: return visitCatchClause(node as CatchClause); - case SyntaxKind.PropertyAccessExpression: - if (capturedSuperProperties && isPropertyAccessExpression(node) && node.expression.kind === SyntaxKind.SuperKeyword) { - capturedSuperProperties.set(node.name.escapedText, true); - } - return visitEachChild(node, visitor, context); - case SyntaxKind.ElementAccessExpression: - if (capturedSuperProperties && (node).expression.kind === SyntaxKind.SuperKeyword) { - hasSuperElementAccess = true; - } - return visitEachChild(node, visitor, context); default: return visitEachChild(node, visitor, context); } } - function visitAwaitExpression(node: AwaitExpression): Expression { - if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { - return setOriginalNode( - setTextRange( - createYield(createAwaitHelper(context, visitNode(node.expression, visitor, isExpression))), - /*location*/ node - ), - node - ); - } - return visitEachChild(node, visitor, context); - } - - function visitYieldExpression(node: YieldExpression) { - if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { - if (node.asteriskToken) { - const expression = visitNode(node.expression, visitor, isExpression); - - return setOriginalNode( - setTextRange( - createYield( - createAwaitHelper(context, - updateYield( - node, - node.asteriskToken, - createAsyncDelegatorHelper( - context, - createAsyncValuesHelper(context, expression, expression), - expression - ) - ) - ) - ), - node - ), - node - ); - } - - return setOriginalNode( - setTextRange( - createYield( - createDownlevelAwait( - node.expression - ? visitNode(node.expression, visitor, isExpression) - : createVoidZero() - ) - ), - node - ), - node - ); - } - - return visitEachChild(node, visitor, context); - } - - function visitReturnStatement(node: ReturnStatement) { - if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) { - return updateReturn(node, createDownlevelAwait( - node.expression ? visitNode(node.expression, visitor, isExpression) : createVoidZero() - )); - } - - return visitEachChild(node, visitor, context); - } - - function visitLabeledStatement(node: LabeledStatement) { - if (enclosingFunctionFlags & FunctionFlags.Async) { - const statement = unwrapInnermostStatementOfLabel(node); - if (statement.kind === SyntaxKind.ForOfStatement && (statement).awaitModifier) { - return visitForOfStatement(statement, node); - } - return restoreEnclosingLabel(visitEachChild(statement, visitor, context), node); - } - return visitEachChild(node, visitor, context); - } - - function chunkObjectLiteralElements(elements: ReadonlyArray): Expression[] { - let chunkObject: ObjectLiteralElementLike[] | undefined; - const objects: Expression[] = []; - for (const e of elements) { - if (e.kind === SyntaxKind.SpreadAssignment) { - if (chunkObject) { - objects.push(createObjectLiteral(chunkObject)); - chunkObject = undefined; - } - const target = e.expression; - objects.push(visitNode(target, visitor, isExpression)); - } - else { - chunkObject = append(chunkObject, e.kind === SyntaxKind.PropertyAssignment - ? createPropertyAssignment(e.name, visitNode(e.initializer, visitor, isExpression)) - : visitNode(e, visitor, isObjectLiteralElementLike)); - } - } - if (chunkObject) { - objects.push(createObjectLiteral(chunkObject)); - } - - return objects; - } - - function visitObjectLiteralExpression(node: ObjectLiteralExpression): Expression { - if (node.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - // spread elements emit like so: - // non-spread elements are chunked together into object literals, and then all are passed to __assign: - // { a, ...o, b } => __assign({a}, o, {b}); - // If the first element is a spread element, then the first argument to __assign is {}: - // { ...o, a, b, ...o2 } => __assign({}, o, {a, b}, o2) - const objects = chunkObjectLiteralElements(node.properties); - if (objects.length && objects[0].kind !== SyntaxKind.ObjectLiteralExpression) { - objects.unshift(createObjectLiteral()); - } - return createAssignHelper(context, objects); - } - return visitEachChild(node, visitor, context); - } - - function visitExpressionStatement(node: ExpressionStatement): ExpressionStatement { - return visitEachChild(node, visitorNoDestructuringValue, context); - } - - function visitParenthesizedExpression(node: ParenthesizedExpression, noDestructuringValue: boolean): ParenthesizedExpression { - return visitEachChild(node, noDestructuringValue ? visitorNoDestructuringValue : visitor, context); - } - function visitCatchClause(node: CatchClause): CatchClause { if (!node.variableDeclaration) { return updateCatchClause( @@ -259,801 +33,5 @@ namespace ts { } return visitEachChild(node, visitor, context); } - - /** - * Visits a BinaryExpression that contains a destructuring assignment. - * - * @param node A BinaryExpression node. - */ - function visitBinaryExpression(node: BinaryExpression, noDestructuringValue: boolean): Expression { - if (isDestructuringAssignment(node) && node.left.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - return flattenDestructuringAssignment( - node, - visitor, - context, - FlattenLevel.ObjectRest, - !noDestructuringValue - ); - } - else if (node.operatorToken.kind === SyntaxKind.CommaToken) { - return updateBinary( - node, - visitNode(node.left, visitorNoDestructuringValue, isExpression), - visitNode(node.right, noDestructuringValue ? visitorNoDestructuringValue : visitor, isExpression) - ); - } - return visitEachChild(node, visitor, context); - } - - /** - * Visits a VariableDeclaration node with a binding pattern. - * - * @param node A VariableDeclaration node. - */ - function visitVariableDeclaration(node: VariableDeclaration): VisitResult { - // If we are here it is because the name contains a binding pattern with a rest somewhere in it. - if (isBindingPattern(node.name) && node.name.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - return flattenDestructuringBinding( - node, - visitor, - context, - FlattenLevel.ObjectRest - ); - } - return visitEachChild(node, visitor, context); - } - - function visitForStatement(node: ForStatement): VisitResult { - return updateFor( - node, - visitNode(node.initializer, visitorNoDestructuringValue, isForInitializer), - visitNode(node.condition, visitor, isExpression), - visitNode(node.incrementor, visitor, isExpression), - visitNode(node.statement, visitor, isStatement) - ); - } - - function visitVoidExpression(node: VoidExpression) { - return visitEachChild(node, visitorNoDestructuringValue, context); - } - - /** - * Visits a ForOfStatement and converts it into a ES2015-compatible ForOfStatement. - * - * @param node A ForOfStatement. - */ - function visitForOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement | undefined): VisitResult { - if (node.initializer.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - node = transformForOfStatementWithObjectRest(node); - } - if (node.awaitModifier) { - return transformForAwaitOfStatement(node, outermostLabeledStatement); - } - else { - return restoreEnclosingLabel(visitEachChild(node, visitor, context), outermostLabeledStatement); - } - } - - function transformForOfStatementWithObjectRest(node: ForOfStatement) { - const initializerWithoutParens = skipParentheses(node.initializer) as ForInitializer; - if (isVariableDeclarationList(initializerWithoutParens) || isAssignmentPattern(initializerWithoutParens)) { - let bodyLocation: TextRange | undefined; - let statementsLocation: TextRange | undefined; - const temp = createTempVariable(/*recordTempVariable*/ undefined); - const statements: Statement[] = [createForOfBindingStatement(initializerWithoutParens, temp)]; - if (isBlock(node.statement)) { - addRange(statements, node.statement.statements); - bodyLocation = node.statement; - statementsLocation = node.statement.statements; - } - else if (node.statement) { - append(statements, node.statement); - bodyLocation = node.statement; - statementsLocation = node.statement; - } - return updateForOf( - node, - node.awaitModifier, - setTextRange( - createVariableDeclarationList( - [ - setTextRange(createVariableDeclaration(temp), node.initializer) - ], - NodeFlags.Let - ), - node.initializer - ), - node.expression, - setTextRange( - createBlock( - setTextRange(createNodeArray(statements), statementsLocation), - /*multiLine*/ true - ), - bodyLocation - ) - ); - } - return node; - } - - function convertForOfStatementHead(node: ForOfStatement, boundValue: Expression) { - const binding = createForOfBindingStatement(node.initializer, boundValue); - - let bodyLocation: TextRange | undefined; - let statementsLocation: TextRange | undefined; - const statements: Statement[] = [visitNode(binding, visitor, isStatement)]; - const statement = visitNode(node.statement, visitor, isStatement); - if (isBlock(statement)) { - addRange(statements, statement.statements); - bodyLocation = statement; - statementsLocation = statement.statements; - } - else { - statements.push(statement); - } - - return setEmitFlags( - setTextRange( - createBlock( - setTextRange(createNodeArray(statements), statementsLocation), - /*multiLine*/ true - ), - bodyLocation - ), - EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps - ); - } - - function createDownlevelAwait(expression: Expression) { - return enclosingFunctionFlags & FunctionFlags.Generator - ? createYield(/*asteriskToken*/ undefined, createAwaitHelper(context, expression)) - : createAwait(expression); - } - - function transformForAwaitOfStatement(node: ForOfStatement, outermostLabeledStatement: LabeledStatement | undefined) { - const expression = visitNode(node.expression, visitor, isExpression); - const iterator = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined); - const result = isIdentifier(expression) ? getGeneratedNameForNode(iterator) : createTempVariable(/*recordTempVariable*/ undefined); - const errorRecord = createUniqueName("e"); - const catchVariable = getGeneratedNameForNode(errorRecord); - const returnMethod = createTempVariable(/*recordTempVariable*/ undefined); - const callValues = createAsyncValuesHelper(context, expression, /*location*/ node.expression); - const callNext = createCall(createPropertyAccess(iterator, "next"), /*typeArguments*/ undefined, []); - const getDone = createPropertyAccess(result, "done"); - const getValue = createPropertyAccess(result, "value"); - const callReturn = createFunctionCall(returnMethod, iterator, []); - - hoistVariableDeclaration(errorRecord); - hoistVariableDeclaration(returnMethod); - - const forStatement = setEmitFlags( - setTextRange( - createFor( - /*initializer*/ setEmitFlags( - setTextRange( - createVariableDeclarationList([ - setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, callValues), node.expression), - createVariableDeclaration(result) - ]), - node.expression - ), - EmitFlags.NoHoisting - ), - /*condition*/ createComma( - createAssignment(result, createDownlevelAwait(callNext)), - createLogicalNot(getDone) - ), - /*incrementor*/ undefined, - /*statement*/ convertForOfStatementHead(node, getValue) - ), - /*location*/ node - ), - EmitFlags.NoTokenTrailingSourceMaps - ); - - return createTry( - createBlock([ - restoreEnclosingLabel( - forStatement, - outermostLabeledStatement - ) - ]), - createCatchClause( - createVariableDeclaration(catchVariable), - setEmitFlags( - createBlock([ - createExpressionStatement( - createAssignment( - errorRecord, - createObjectLiteral([ - createPropertyAssignment("error", catchVariable) - ]) - ) - ) - ]), - EmitFlags.SingleLine - ) - ), - createBlock([ - createTry( - /*tryBlock*/ createBlock([ - setEmitFlags( - createIf( - createLogicalAnd( - createLogicalAnd( - result, - createLogicalNot(getDone) - ), - createAssignment( - returnMethod, - createPropertyAccess(iterator, "return") - ) - ), - createExpressionStatement(createDownlevelAwait(callReturn)) - ), - EmitFlags.SingleLine - ) - ]), - /*catchClause*/ undefined, - /*finallyBlock*/ setEmitFlags( - createBlock([ - setEmitFlags( - createIf( - errorRecord, - createThrow( - createPropertyAccess(errorRecord, "error") - ) - ), - EmitFlags.SingleLine - ) - ]), - EmitFlags.SingleLine - ) - ) - ]) - ); - } - - function visitParameter(node: ParameterDeclaration): ParameterDeclaration { - if (node.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - // Binding patterns are converted into a generated name and are - // evaluated inside the function body. - return updateParameter( - node, - /*decorators*/ undefined, - /*modifiers*/ undefined, - node.dotDotDotToken, - getGeneratedNameForNode(node), - /*questionToken*/ undefined, - /*type*/ undefined, - visitNode(node.initializer, visitor, isExpression) - ); - } - return visitEachChild(node, visitor, context); - } - - function visitConstructorDeclaration(node: ConstructorDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = FunctionFlags.Normal; - const updated = updateConstructor( - node, - /*decorators*/ undefined, - node.modifiers, - visitParameterList(node.parameters, visitor, context), - transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitGetAccessorDeclaration(node: GetAccessorDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = FunctionFlags.Normal; - const updated = updateGetAccessor( - node, - /*decorators*/ undefined, - node.modifiers, - visitNode(node.name, visitor, isPropertyName), - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitSetAccessorDeclaration(node: SetAccessorDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = FunctionFlags.Normal; - const updated = updateSetAccessor( - node, - /*decorators*/ undefined, - node.modifiers, - visitNode(node.name, visitor, isPropertyName), - visitParameterList(node.parameters, visitor, context), - transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitMethodDeclaration(node: MethodDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = getFunctionFlags(node); - const updated = updateMethod( - node, - /*decorators*/ undefined, - enclosingFunctionFlags & FunctionFlags.Generator - ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) - : node.modifiers, - enclosingFunctionFlags & FunctionFlags.Async - ? undefined - : node.asteriskToken, - visitNode(node.name, visitor, isPropertyName), - visitNode>(/*questionToken*/ undefined, visitor, isToken), - /*typeParameters*/ undefined, - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator - ? transformAsyncGeneratorFunctionBody(node) - : transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitFunctionDeclaration(node: FunctionDeclaration) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = getFunctionFlags(node); - const updated = updateFunctionDeclaration( - node, - /*decorators*/ undefined, - enclosingFunctionFlags & FunctionFlags.Generator - ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) - : node.modifiers, - enclosingFunctionFlags & FunctionFlags.Async - ? undefined - : node.asteriskToken, - node.name, - /*typeParameters*/ undefined, - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator - ? transformAsyncGeneratorFunctionBody(node) - : transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitArrowFunction(node: ArrowFunction) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = getFunctionFlags(node); - const updated = updateArrowFunction( - node, - node.modifiers, - /*typeParameters*/ undefined, - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - node.equalsGreaterThanToken, - transformFunctionBody(node), - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function visitFunctionExpression(node: FunctionExpression) { - const savedEnclosingFunctionFlags = enclosingFunctionFlags; - enclosingFunctionFlags = getFunctionFlags(node); - const updated = updateFunctionExpression( - node, - enclosingFunctionFlags & FunctionFlags.Generator - ? visitNodes(node.modifiers, visitorNoAsyncModifier, isModifier) - : node.modifiers, - enclosingFunctionFlags & FunctionFlags.Async - ? undefined - : node.asteriskToken, - node.name, - /*typeParameters*/ undefined, - visitParameterList(node.parameters, visitor, context), - /*type*/ undefined, - enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator - ? transformAsyncGeneratorFunctionBody(node) - : transformFunctionBody(node) - ); - enclosingFunctionFlags = savedEnclosingFunctionFlags; - return updated; - } - - function transformAsyncGeneratorFunctionBody(node: MethodDeclaration | AccessorDeclaration | FunctionDeclaration | FunctionExpression): FunctionBody { - resumeLexicalEnvironment(); - const statements: Statement[] = []; - const statementOffset = addPrologue(statements, node.body!.statements, /*ensureUseStrict*/ false, visitor); - appendObjectRestAssignmentsIfNeeded(statements, node); - - const savedCapturedSuperProperties = capturedSuperProperties; - const savedHasSuperElementAccess = hasSuperElementAccess; - capturedSuperProperties = createUnderscoreEscapedMap(); - hasSuperElementAccess = false; - - const returnStatement = createReturn( - createAsyncGeneratorHelper( - context, - createFunctionExpression( - /*modifiers*/ undefined, - createToken(SyntaxKind.AsteriskToken), - node.name && getGeneratedNameForNode(node.name), - /*typeParameters*/ undefined, - /*parameters*/ [], - /*type*/ undefined, - updateBlock( - node.body!, - visitLexicalEnvironment(node.body!.statements, visitor, context, statementOffset) - ) - ) - ) - ); - - // Minor optimization, emit `_super` helper to capture `super` access in an arrow. - // This step isn't needed if we eventually transform this to ES5. - const emitSuperHelpers = languageVersion >= ScriptTarget.ES2015 && resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuperBinding | NodeCheckFlags.AsyncMethodWithSuper); - - if (emitSuperHelpers) { - enableSubstitutionForAsyncMethodsWithSuper(); - const variableStatement = createSuperAccessVariableStatement(resolver, node, capturedSuperProperties); - substitutedSuperAccessors[getNodeId(variableStatement)] = true; - addStatementsAfterPrologue(statements, [variableStatement]); - } - - statements.push(returnStatement); - - addStatementsAfterPrologue(statements, endLexicalEnvironment()); - const block = updateBlock(node.body!, statements); - - if (emitSuperHelpers && hasSuperElementAccess) { - if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuperBinding) { - addEmitHelper(block, advancedAsyncSuperHelper); - } - else if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuper) { - addEmitHelper(block, asyncSuperHelper); - } - } - - capturedSuperProperties = savedCapturedSuperProperties; - hasSuperElementAccess = savedHasSuperElementAccess; - - return block; - } - - function transformFunctionBody(node: FunctionDeclaration | FunctionExpression | ConstructorDeclaration | MethodDeclaration | AccessorDeclaration): FunctionBody; - function transformFunctionBody(node: ArrowFunction): ConciseBody; - function transformFunctionBody(node: FunctionLikeDeclaration): ConciseBody { - resumeLexicalEnvironment(); - let statementOffset = 0; - const statements: Statement[] = []; - const body = visitNode(node.body, visitor, isConciseBody); - if (isBlock(body)) { - statementOffset = addPrologue(statements, body.statements, /*ensureUseStrict*/ false, visitor); - } - addRange(statements, appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node)); - const leadingStatements = endLexicalEnvironment(); - if (statementOffset > 0 || some(statements) || some(leadingStatements)) { - const block = convertToFunctionBody(body, /*multiLine*/ true); - addStatementsAfterPrologue(statements, leadingStatements); - addRange(statements, block.statements.slice(statementOffset)); - return updateBlock(block, setTextRange(createNodeArray(statements), block.statements)); - } - return body; - } - - function appendObjectRestAssignmentsIfNeeded(statements: Statement[] | undefined, node: FunctionLikeDeclaration): Statement[] | undefined { - for (const parameter of node.parameters) { - if (parameter.transformFlags & TransformFlags.ContainsObjectRestOrSpread) { - const temp = getGeneratedNameForNode(parameter); - const declarations = flattenDestructuringBinding( - parameter, - visitor, - context, - FlattenLevel.ObjectRest, - temp, - /*doNotRecordTempVariablesInLine*/ false, - /*skipInitializer*/ true, - ); - if (some(declarations)) { - const statement = createVariableStatement( - /*modifiers*/ undefined, - createVariableDeclarationList( - declarations - ) - ); - setEmitFlags(statement, EmitFlags.CustomPrologue); - statements = append(statements, statement); - } - } - } - return statements; - } - - function enableSubstitutionForAsyncMethodsWithSuper() { - if ((enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper) === 0) { - enabledSubstitutions |= ESNextSubstitutionFlags.AsyncMethodsWithSuper; - - // We need to enable substitutions for call, property access, and element access - // if we need to rewrite super calls. - context.enableSubstitution(SyntaxKind.CallExpression); - context.enableSubstitution(SyntaxKind.PropertyAccessExpression); - context.enableSubstitution(SyntaxKind.ElementAccessExpression); - - // We need to be notified when entering and exiting declarations that bind super. - context.enableEmitNotification(SyntaxKind.ClassDeclaration); - context.enableEmitNotification(SyntaxKind.MethodDeclaration); - context.enableEmitNotification(SyntaxKind.GetAccessor); - context.enableEmitNotification(SyntaxKind.SetAccessor); - context.enableEmitNotification(SyntaxKind.Constructor); - // We need to be notified when entering the generated accessor arrow functions. - context.enableEmitNotification(SyntaxKind.VariableStatement); - } - } - - /** - * Called by the printer just before a node is printed. - * - * @param hint A hint as to the intended usage of the node. - * @param node The node to be printed. - * @param emitCallback The callback used to emit the node. - */ - function onEmitNode(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) { - // If we need to support substitutions for `super` in an async method, - // we should track it here. - if (enabledSubstitutions & ESNextSubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) { - const superContainerFlags = resolver.getNodeCheckFlags(node) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding); - if (superContainerFlags !== enclosingSuperContainerFlags) { - const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; - enclosingSuperContainerFlags = superContainerFlags; - previousOnEmitNode(hint, node, emitCallback); - enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; - return; - } - } - // Disable substitution in the generated super accessor itself. - else if (enabledSubstitutions && substitutedSuperAccessors[getNodeId(node)]) { - const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; - enclosingSuperContainerFlags = 0 as NodeCheckFlags; - previousOnEmitNode(hint, node, emitCallback); - enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; - return; - } - - previousOnEmitNode(hint, node, emitCallback); - } - - /** - * Hooks node substitutions. - * - * @param hint The context for the emitter. - * @param node The node to substitute. - */ - function onSubstituteNode(hint: EmitHint, node: Node) { - node = previousOnSubstituteNode(hint, node); - if (hint === EmitHint.Expression && enclosingSuperContainerFlags) { - return substituteExpression(node); - } - return node; - } - - function substituteExpression(node: Expression) { - switch (node.kind) { - case SyntaxKind.PropertyAccessExpression: - return substitutePropertyAccessExpression(node); - case SyntaxKind.ElementAccessExpression: - return substituteElementAccessExpression(node); - case SyntaxKind.CallExpression: - return substituteCallExpression(node); - } - return node; - } - - function substitutePropertyAccessExpression(node: PropertyAccessExpression) { - if (node.expression.kind === SyntaxKind.SuperKeyword) { - return setTextRange( - createPropertyAccess( - createFileLevelUniqueName("_super"), - node.name), - node - ); - } - return node; - } - - function substituteElementAccessExpression(node: ElementAccessExpression) { - if (node.expression.kind === SyntaxKind.SuperKeyword) { - return createSuperElementAccessInAsyncMethod( - node.argumentExpression, - node - ); - } - return node; - } - - function substituteCallExpression(node: CallExpression): Expression { - const expression = node.expression; - if (isSuperProperty(expression)) { - const argumentExpression = isPropertyAccessExpression(expression) - ? substitutePropertyAccessExpression(expression) - : substituteElementAccessExpression(expression); - return createCall( - createPropertyAccess(argumentExpression, "call"), - /*typeArguments*/ undefined, - [ - createThis(), - ...node.arguments - ] - ); - } - return node; - } - - function isSuperContainer(node: Node) { - const kind = node.kind; - return kind === SyntaxKind.ClassDeclaration - || kind === SyntaxKind.Constructor - || kind === SyntaxKind.MethodDeclaration - || kind === SyntaxKind.GetAccessor - || kind === SyntaxKind.SetAccessor; - } - - function createSuperElementAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression { - if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) { - return setTextRange( - createPropertyAccess( - createCall( - createIdentifier("_superIndex"), - /*typeArguments*/ undefined, - [argumentExpression] - ), - "value" - ), - location - ); - } - else { - return setTextRange( - createCall( - createIdentifier("_superIndex"), - /*typeArguments*/ undefined, - [argumentExpression] - ), - location - ); - } - } - } - - export const assignHelper: UnscopedEmitHelpers = { - name: "typescript:assign", - scoped: false, - priority: 1, - text: ` - var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); - };` - }; - - export function createAssignHelper(context: TransformationContext, attributesSegments: Expression[]) { - if (context.getCompilerOptions().target! >= ScriptTarget.ES2015) { - return createCall(createPropertyAccess(createIdentifier("Object"), "assign"), - /*typeArguments*/ undefined, - attributesSegments); - } - context.requestEmitHelper(assignHelper); - return createCall( - getHelperName("__assign"), - /*typeArguments*/ undefined, - attributesSegments - ); - } - - export const awaitHelper: UnscopedEmitHelpers = { - name: "typescript:await", - scoped: false, - text: ` - var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }` - }; - - function createAwaitHelper(context: TransformationContext, expression: Expression) { - context.requestEmitHelper(awaitHelper); - return createCall(getHelperName("__await"), /*typeArguments*/ undefined, [expression]); - } - - export const asyncGeneratorHelper: UnscopedEmitHelpers = { - name: "typescript:asyncGenerator", - scoped: false, - text: ` - var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { - if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); - var g = generator.apply(thisArg, _arguments || []), i, q = []; - return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; - function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } - function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } - function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } - function fulfill(value) { resume("next", value); } - function reject(value) { resume("throw", value); } - function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } - };` - }; - - function createAsyncGeneratorHelper(context: TransformationContext, generatorFunc: FunctionExpression) { - context.requestEmitHelper(awaitHelper); - context.requestEmitHelper(asyncGeneratorHelper); - - // Mark this node as originally an async function - (generatorFunc.emitNode || (generatorFunc.emitNode = {} as EmitNode)).flags |= EmitFlags.AsyncFunctionBody; - - return createCall( - getHelperName("__asyncGenerator"), - /*typeArguments*/ undefined, - [ - createThis(), - createIdentifier("arguments"), - generatorFunc - ] - ); - } - - export const asyncDelegator: UnscopedEmitHelpers = { - name: "typescript:asyncDelegator", - scoped: false, - text: ` - var __asyncDelegator = (this && this.__asyncDelegator) || function (o) { - var i, p; - return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; - function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; } - };` - }; - - function createAsyncDelegatorHelper(context: TransformationContext, expression: Expression, location?: TextRange) { - context.requestEmitHelper(awaitHelper); - context.requestEmitHelper(asyncDelegator); - return setTextRange( - createCall( - getHelperName("__asyncDelegator"), - /*typeArguments*/ undefined, - [expression] - ), - location - ); - } - - export const asyncValues: UnscopedEmitHelpers = { - name: "typescript:asyncValues", - scoped: false, - text: ` - var __asyncValues = (this && this.__asyncValues) || function (o) { - if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); - var m = o[Symbol.asyncIterator], i; - return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); - function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } - function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } - };` - }; - - function createAsyncValuesHelper(context: TransformationContext, expression: Expression, location?: TextRange) { - context.requestEmitHelper(asyncValues); - return setTextRange( - createCall( - getHelperName("__asyncValues"), - /*typeArguments*/ undefined, - [expression] - ), - location - ); } } diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts index c852e43a185..83575fc4bdb 100644 --- a/src/compiler/transformers/generators.ts +++ b/src/compiler/transformers/generators.ts @@ -3240,7 +3240,7 @@ namespace ts { // entering a finally block. // // For examples of how these are used, see the comments in ./transformers/generators.ts - export const generatorHelper: UnscopedEmitHelpers = { + export const generatorHelper: UnscopedEmitHelper = { name: "typescript:generator", scoped: false, priority: 6, diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts index 54100864197..5605c91e987 100644 --- a/src/compiler/transformers/module/module.ts +++ b/src/compiler/transformers/module/module.ts @@ -1806,7 +1806,7 @@ namespace ts { }; // emit helper for `import * as Name from "foo"` - export const importStarHelper: UnscopedEmitHelpers = { + export const importStarHelper: UnscopedEmitHelper = { name: "typescript:commonjsimportstar", scoped: false, text: ` @@ -1820,7 +1820,7 @@ var __importStar = (this && this.__importStar) || function (mod) { }; // emit helper for `import Name from "foo"` - export const importDefaultHelper: UnscopedEmitHelpers = { + export const importDefaultHelper: UnscopedEmitHelper = { name: "typescript:commonjsimportdefault", scoped: false, text: ` diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index ad5c464b434..15c86a63b94 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -3680,7 +3680,7 @@ namespace ts { ); } - export const decorateHelper: UnscopedEmitHelpers = { + export const decorateHelper: UnscopedEmitHelper = { name: "typescript:decorate", scoped: false, priority: 2, @@ -3705,7 +3705,7 @@ namespace ts { ); } - export const metadataHelper: UnscopedEmitHelpers = { + export const metadataHelper: UnscopedEmitHelper = { name: "typescript:metadata", scoped: false, priority: 3, @@ -3730,7 +3730,7 @@ namespace ts { ); } - export const paramHelper: UnscopedEmitHelpers = { + export const paramHelper: UnscopedEmitHelper = { name: "typescript:param", scoped: false, priority: 4, diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json index c41f47f3c4a..14b7ce377e5 100644 --- a/src/compiler/tsconfig.json +++ b/src/compiler/tsconfig.json @@ -30,6 +30,7 @@ "transformers/destructuring.ts", "transformers/ts.ts", "transformers/es2017.ts", + "transformers/es2018.ts", "transformers/esnext.ts", "transformers/jsx.ts", "transformers/es2016.ts", diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 41cf9eeaa63..4d8c724a7c0 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2786,7 +2786,7 @@ namespace ts { fileName: string; text: string; prologues: ReadonlyArray; - helpers: ReadonlyArray | undefined; + helpers: ReadonlyArray | undefined; // References and noDefaultLibAre Dts only referencedFiles: ReadonlyArray; @@ -4176,7 +4176,6 @@ namespace ts { templateType?: Type; modifiersType?: Type; resolvedApparentType?: Type; - instantiating?: boolean; } export interface EvolvingArrayType extends ObjectType { @@ -5134,6 +5133,7 @@ namespace ts { ContainsDynamicImport = 1 << 24, Super = 1 << 25, ContainsSuper = 1 << 26, + ContainsES2018 = 1 << 27, // Please leave this as 1 << 29. // It is the maximum bit we can set before we outgrow the size of a v8 small integer (SMI) on an x86 system. @@ -5145,6 +5145,7 @@ namespace ts { AssertTypeScript = TypeScript | ContainsTypeScript, AssertJsx = ContainsJsx, AssertESNext = ContainsESNext, + AssertES2018 = ContainsES2018, AssertES2017 = ContainsES2017, AssertES2016 = ContainsES2016, AssertES2015 = ES2015 | ContainsES2015, @@ -5243,7 +5244,7 @@ namespace ts { readonly priority?: number; // Helpers with a higher priority are emitted earlier than other helpers on the node. } - export interface UnscopedEmitHelpers extends EmitHelper { + export interface UnscopedEmitHelper extends EmitHelper { readonly scoped: false; // Indicates whether the helper MUST be emitted in the current scope. readonly text: string; // ES3-compatible raw script text, or a function yielding such a string } @@ -6018,7 +6019,7 @@ namespace ts { export interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; readonly includeCompletionsForModuleExports?: boolean; readonly includeCompletionsWithInsertText?: boolean; readonly importModuleSpecifierPreference?: "relative" | "non-relative"; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 28e78e9e236..f3a2d69b493 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2514,14 +2514,15 @@ namespace ts { } export function getEffectiveBaseTypeNode(node: ClassLikeDeclaration | InterfaceDeclaration) { - if (isInJSFile(node)) { + const baseType = getClassExtendsHeritageElement(node); + if (baseType && isInJSFile(node)) { // Prefer an @augments tag because it may have type parameters. const tag = getJSDocAugmentsTag(node); if (tag) { return tag.class; } } - return getClassExtendsHeritageElement(node); + return baseType; } export function getClassExtendsHeritageElement(node: ClassLikeDeclaration | InterfaceDeclaration) { diff --git a/src/server/protocol.ts b/src/server/protocol.ts index 11930de4d8c..1fd8d98b570 100644 --- a/src/server/protocol.ts +++ b/src/server/protocol.ts @@ -2891,7 +2891,7 @@ namespace ts.server.protocol { export interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; /** * If enabled, TypeScript will search through all external modules' exports and add them to the completions list. * This affects lone identifier completions but not completions on the right hand side of `obj.`. diff --git a/src/services/codefixes/helpers.ts b/src/services/codefixes/helpers.ts index 4309e6ec35d..ec86415b9fa 100644 --- a/src/services/codefixes/helpers.ts +++ b/src/services/codefixes/helpers.ts @@ -264,6 +264,7 @@ namespace ts.codefix { createNew( createIdentifier("Error"), /*typeArguments*/ undefined, + // TODO Handle auto quote preference. [createLiteral("Method not implemented.", /*isSingleQuote*/ preferences.quotePreference === "single")]))], /*multiline*/ true); } diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 2f78ef2324b..285ca0cc6a9 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -1315,7 +1315,7 @@ namespace ts { } export function getQuotePreference(sourceFile: SourceFile, preferences: UserPreferences): QuotePreference { - if (preferences.quotePreference) { + if (preferences.quotePreference && preferences.quotePreference !== "auto") { return preferences.quotePreference === "single" ? QuotePreference.Single : QuotePreference.Double; } else { @@ -1868,15 +1868,18 @@ namespace ts { if (/^\d+$/.test(text)) { return text; } + // Editors can pass in undefined or empty string - we want to infer the preference in those cases. + const quotePreference = preferences.quotePreference || "auto"; const quoted = JSON.stringify(text); - switch (preferences.quotePreference) { - case undefined: + switch (quotePreference) { + // TODO use getQuotePreference to infer the actual quote style. + case "auto": case "double": return quoted; case "single": return `'${stripQuotes(quoted).replace("'", "\\'").replace('\\"', '"')}'`; default: - return Debug.assertNever(preferences.quotePreference); + return Debug.assertNever(quotePreference); } } diff --git a/src/testRunner/unittests/asserts.ts b/src/testRunner/unittests/asserts.ts index c54173e2f90..116a74cf179 100644 --- a/src/testRunner/unittests/asserts.ts +++ b/src/testRunner/unittests/asserts.ts @@ -5,5 +5,8 @@ namespace ts { assert.throws(() => assert.deepEqual(createNodeArray([], /*hasTrailingComma*/ true), createNodeArray([], /*hasTrailingComma*/ false))); assert.deepEqual(createNodeArray([createIdentifier("A")], /*hasTrailingComma*/ true), createNodeArray([createIdentifier("A")], /*hasTrailingComma*/ true)); }); + it("assertNever on string has correct error", () => { + assert.throws(() => Debug.assertNever("hi" as never), "Debug Failure. Illegal value: \"hi\""); + }); }); } diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 25b102ac3ed..53b8786b961 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -1745,7 +1745,7 @@ declare namespace ts { fileName: string; text: string; prologues: ReadonlyArray; - helpers: ReadonlyArray | undefined; + helpers: ReadonlyArray | undefined; referencedFiles: ReadonlyArray; typeReferenceDirectives: ReadonlyArray | undefined; libReferenceDirectives: ReadonlyArray; @@ -2792,7 +2792,7 @@ declare namespace ts { readonly text: string | ((node: EmitHelperUniqueNameCallback) => string); readonly priority?: number; } - interface UnscopedEmitHelpers extends EmitHelper { + interface UnscopedEmitHelper extends EmitHelper { readonly scoped: false; readonly text: string; } @@ -3055,7 +3055,7 @@ declare namespace ts { } interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; readonly includeCompletionsForModuleExports?: boolean; readonly includeCompletionsWithInsertText?: boolean; readonly importModuleSpecifierPreference?: "relative" | "non-relative"; @@ -7973,7 +7973,7 @@ declare namespace ts.server.protocol { } interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; /** * If enabled, TypeScript will search through all external modules' exports and add them to the completions list. * This affects lone identifier completions but not completions on the right hand side of `obj.`. diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 1c853897ea7..5e543430ca8 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -1745,7 +1745,7 @@ declare namespace ts { fileName: string; text: string; prologues: ReadonlyArray; - helpers: ReadonlyArray | undefined; + helpers: ReadonlyArray | undefined; referencedFiles: ReadonlyArray; typeReferenceDirectives: ReadonlyArray | undefined; libReferenceDirectives: ReadonlyArray; @@ -2792,7 +2792,7 @@ declare namespace ts { readonly text: string | ((node: EmitHelperUniqueNameCallback) => string); readonly priority?: number; } - interface UnscopedEmitHelpers extends EmitHelper { + interface UnscopedEmitHelper extends EmitHelper { readonly scoped: false; readonly text: string; } @@ -3055,7 +3055,7 @@ declare namespace ts { } interface UserPreferences { readonly disableSuggestions?: boolean; - readonly quotePreference?: "double" | "single"; + readonly quotePreference?: "auto" | "double" | "single"; readonly includeCompletionsForModuleExports?: boolean; readonly includeCompletionsWithInsertText?: boolean; readonly importModuleSpecifierPreference?: "relative" | "non-relative"; diff --git a/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.js b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.js new file mode 100644 index 00000000000..3821fd1b278 --- /dev/null +++ b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.js @@ -0,0 +1,33 @@ +//// [controlFlowFinallyNoCatchAssignments.ts] +let x: number; +x = Math.random(); +let a: number; +try { + if (x) { + a = 1; + } else { + a = 2; + } +} finally { + console.log(x); +} + +console.log(a); // <- error here + +//// [controlFlowFinallyNoCatchAssignments.js] +"use strict"; +var x; +x = Math.random(); +var a; +try { + if (x) { + a = 1; + } + else { + a = 2; + } +} +finally { + console.log(x); +} +console.log(a); // <- error here diff --git a/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.symbols b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.symbols new file mode 100644 index 00000000000..f66f3bbe4b7 --- /dev/null +++ b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.symbols @@ -0,0 +1,38 @@ +=== tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts === +let x: number; +>x : Symbol(x, Decl(controlFlowFinallyNoCatchAssignments.ts, 0, 3)) + +x = Math.random(); +>x : Symbol(x, Decl(controlFlowFinallyNoCatchAssignments.ts, 0, 3)) +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) + +let a: number; +>a : Symbol(a, Decl(controlFlowFinallyNoCatchAssignments.ts, 2, 3)) + +try { + if (x) { +>x : Symbol(x, Decl(controlFlowFinallyNoCatchAssignments.ts, 0, 3)) + + a = 1; +>a : Symbol(a, Decl(controlFlowFinallyNoCatchAssignments.ts, 2, 3)) + + } else { + a = 2; +>a : Symbol(a, Decl(controlFlowFinallyNoCatchAssignments.ts, 2, 3)) + } +} finally { + console.log(x); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>x : Symbol(x, Decl(controlFlowFinallyNoCatchAssignments.ts, 0, 3)) +} + +console.log(a); // <- error here +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>a : Symbol(a, Decl(controlFlowFinallyNoCatchAssignments.ts, 2, 3)) + diff --git a/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.types b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.types new file mode 100644 index 00000000000..7199969d6c3 --- /dev/null +++ b/tests/baselines/reference/controlFlowFinallyNoCatchAssignments.types @@ -0,0 +1,46 @@ +=== tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts === +let x: number; +>x : number + +x = Math.random(); +>x = Math.random() : number +>x : number +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number + +let a: number; +>a : number + +try { + if (x) { +>x : number + + a = 1; +>a = 1 : 1 +>a : number +>1 : 1 + + } else { + a = 2; +>a = 2 : 2 +>a : number +>2 : 2 + } +} finally { + console.log(x); +>console.log(x) : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>x : number +} + +console.log(a); // <- error here +>console.log(a) : void +>console.log : (message?: any, ...optionalParams: any[]) => void +>console : Console +>log : (message?: any, ...optionalParams: any[]) => void +>a : number + diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.js similarity index 88% rename from tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.js rename to tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.js index 84c8aaf009b..6fcebafdd45 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.js +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.classMethods.es2018.ts] //// //// [C1.ts] class C1 { diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.symbols similarity index 73% rename from tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.symbols rename to tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.symbols index 99450781f82..bf5bff3bf3b 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.symbols +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C1.ts === class C1 { >C1 : Symbol(C1, Decl(C1.ts, 0, 0)) @@ -6,7 +6,7 @@ class C1 { >f : Symbol(C1.f, Decl(C1.ts, 0, 10)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C2.ts === class C2 { >C2 : Symbol(C2, Decl(C2.ts, 0, 0)) @@ -17,7 +17,7 @@ class C2 { >x : Symbol(x, Decl(C2.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C3.ts === class C3 { >C3 : Symbol(C3, Decl(C3.ts, 0, 0)) @@ -28,7 +28,7 @@ class C3 { >x : Symbol(x, Decl(C3.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C4.ts === class C4 { >C4 : Symbol(C4, Decl(C4.ts, 0, 0)) @@ -39,7 +39,7 @@ class C4 { >x : Symbol(x, Decl(C4.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C5.ts === class C5 { >C5 : Symbol(C5, Decl(C5.ts, 0, 0)) @@ -50,7 +50,7 @@ class C5 { >x : Symbol(x, Decl(C5.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C6.ts === class C6 { >C6 : Symbol(C6, Decl(C6.ts, 0, 0)) @@ -61,7 +61,7 @@ class C6 { >x : Symbol(x, Decl(C6.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C7.ts === class C7 { >C7 : Symbol(C7, Decl(C7.ts, 0, 0)) @@ -71,7 +71,7 @@ class C7 { return 1; } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C8.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C8.ts === class C8 { >C8 : Symbol(C8, Decl(C8.ts, 0, 0)) @@ -87,7 +87,7 @@ class C8 { >g : Symbol(C8.g, Decl(C8.ts, 0, 10)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C9.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C9.ts === class B9 { >B9 : Symbol(B9, Decl(C9.ts, 0, 0)) diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types similarity index 70% rename from tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.types rename to tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types index f2f5f4d7503..17fefc54e81 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.esnext.types +++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C1.ts === class C1 { >C1 : C1 @@ -6,7 +6,7 @@ class C1 { >f : () => AsyncIterableIterator } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C2.ts === class C2 { >C2 : C2 @@ -18,7 +18,7 @@ class C2 { >yield : any } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C3.ts === class C3 { >C3 : C3 @@ -31,7 +31,7 @@ class C3 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C4.ts === class C4 { >C4 : C4 @@ -45,7 +45,7 @@ class C4 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C5.ts === class C5 { >C5 : C5 @@ -62,7 +62,7 @@ class C5 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C6.ts === class C6 { >C6 : C6 @@ -75,7 +75,7 @@ class C6 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C7.ts === class C7 { >C7 : C7 @@ -86,7 +86,7 @@ class C7 { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C8.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C8.ts === class C8 { >C8 : C8 @@ -103,7 +103,7 @@ class C8 { >g : () => void } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/C9.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/C9.ts === class B9 { >B9 : B9 diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.js similarity index 83% rename from tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.js rename to tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.js index 57708e027a3..6937d84f276 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2018.ts] //// //// [F1.ts] async function * f1() { diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.symbols similarity index 62% rename from tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.symbols rename to tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.symbols index 018b7d7e07a..a93cc2ccbb0 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.symbols +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.symbols @@ -1,43 +1,43 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts === async function * f1() { >f1 : Symbol(f1, Decl(F1.ts, 0, 0)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts === async function * f2() { >f2 : Symbol(f2, Decl(F2.ts, 0, 0)) const x = yield; >x : Symbol(x, Decl(F2.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts === async function * f3() { >f3 : Symbol(f3, Decl(F3.ts, 0, 0)) const x = yield 1; >x : Symbol(x, Decl(F3.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts === async function * f4() { >f4 : Symbol(f4, Decl(F4.ts, 0, 0)) const x = yield* [1]; >x : Symbol(x, Decl(F4.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts === async function * f5() { >f5 : Symbol(f5, Decl(F5.ts, 0, 0)) const x = yield* (async function*() { yield 1; })(); >x : Symbol(x, Decl(F5.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts === async function * f6() { >f6 : Symbol(f6, Decl(F6.ts, 0, 0)) const x = await 1; >x : Symbol(x, Decl(F6.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts === async function * f7() { >f7 : Symbol(f7, Decl(F7.ts, 0, 0)) diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types similarity index 68% rename from tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.types rename to tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types index c0d80117746..8ffd5534e40 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.esnext.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types @@ -1,8 +1,8 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts === async function * f1() { >f1 : () => AsyncIterableIterator } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts === async function * f2() { >f2 : () => AsyncIterableIterator @@ -10,7 +10,7 @@ async function * f2() { >x : any >yield : any } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts === async function * f3() { >f3 : () => AsyncIterableIterator @@ -19,7 +19,7 @@ async function * f3() { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts === async function * f4() { >f4 : () => AsyncIterableIterator @@ -29,7 +29,7 @@ async function * f4() { >[1] : number[] >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts === async function * f5() { >f5 : () => AsyncIterableIterator @@ -42,7 +42,7 @@ async function * f5() { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts === async function * f6() { >f6 : () => AsyncIterableIterator @@ -51,7 +51,7 @@ async function * f6() { >await 1 : 1 >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts === async function * f7() { >f7 : () => AsyncIterableIterator diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.js similarity index 85% rename from tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.js rename to tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.js index 349fea53b7a..f9be141c5b2 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.js +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2018.ts] //// //// [F1.ts] const f1 = async function * () { diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.symbols similarity index 63% rename from tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.symbols rename to tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.symbols index e59d8429fb7..06c2d7a580e 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.symbols +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.symbols @@ -1,43 +1,43 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts === const f1 = async function * () { >f1 : Symbol(f1, Decl(F1.ts, 0, 5)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts === const f2 = async function * () { >f2 : Symbol(f2, Decl(F2.ts, 0, 5)) const x = yield; >x : Symbol(x, Decl(F2.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts === const f3 = async function * () { >f3 : Symbol(f3, Decl(F3.ts, 0, 5)) const x = yield 1; >x : Symbol(x, Decl(F3.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts === const f4 = async function * () { >f4 : Symbol(f4, Decl(F4.ts, 0, 5)) const x = yield* [1]; >x : Symbol(x, Decl(F4.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts === const f5 = async function * () { >f5 : Symbol(f5, Decl(F5.ts, 0, 5)) const x = yield* (async function*() { yield 1; })(); >x : Symbol(x, Decl(F5.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts === const f6 = async function * () { >f6 : Symbol(f6, Decl(F6.ts, 0, 5)) const x = await 1; >x : Symbol(x, Decl(F6.ts, 1, 9)) } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts === const f7 = async function * () { >f7 : Symbol(f7, Decl(F7.ts, 0, 5)) diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types similarity index 77% rename from tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.types rename to tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types index 5802bc10a2d..07ee0579bed 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.esnext.types +++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types @@ -1,9 +1,9 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts === const f1 = async function * () { >f1 : () => AsyncIterableIterator >async function * () {} : () => AsyncIterableIterator } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts === const f2 = async function * () { >f2 : () => AsyncIterableIterator >async function * () { const x = yield;} : () => AsyncIterableIterator @@ -12,7 +12,7 @@ const f2 = async function * () { >x : any >yield : any } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts === const f3 = async function * () { >f3 : () => AsyncIterableIterator >async function * () { const x = yield 1;} : () => AsyncIterableIterator @@ -22,7 +22,7 @@ const f3 = async function * () { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts === const f4 = async function * () { >f4 : () => AsyncIterableIterator >async function * () { const x = yield* [1];} : () => AsyncIterableIterator @@ -33,7 +33,7 @@ const f4 = async function * () { >[1] : number[] >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts === const f5 = async function * () { >f5 : () => AsyncIterableIterator >async function * () { const x = yield* (async function*() { yield 1; })();} : () => AsyncIterableIterator @@ -47,7 +47,7 @@ const f5 = async function * () { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts === const f6 = async function * () { >f6 : () => AsyncIterableIterator >async function * () { const x = await 1;} : () => AsyncIterableIterator @@ -57,7 +57,7 @@ const f6 = async function * () { >await 1 : 1 >1 : 1 } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/F7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts === const f7 = async function * () { >f7 : () => AsyncIterableIterator >async function * () { return 1;} : () => AsyncIterableIterator diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.js b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.js similarity index 86% rename from tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.js rename to tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.js index a1877b38184..765e6a2fdfa 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.js +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2018.ts] //// //// [O1.ts] const o1 = { diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.symbols b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.symbols similarity index 69% rename from tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.symbols rename to tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.symbols index c1c7847c592..a0e4794068b 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.symbols +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O1.ts === const o1 = { >o1 : Symbol(o1, Decl(O1.ts, 0, 5)) @@ -6,7 +6,7 @@ const o1 = { >f : Symbol(f, Decl(O1.ts, 0, 12)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O2.ts === const o2 = { >o2 : Symbol(o2, Decl(O2.ts, 0, 5)) @@ -17,7 +17,7 @@ const o2 = { >x : Symbol(x, Decl(O2.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O3.ts === const o3 = { >o3 : Symbol(o3, Decl(O3.ts, 0, 5)) @@ -28,7 +28,7 @@ const o3 = { >x : Symbol(x, Decl(O3.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O4.ts === const o4 = { >o4 : Symbol(o4, Decl(O4.ts, 0, 5)) @@ -39,7 +39,7 @@ const o4 = { >x : Symbol(x, Decl(O4.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O5.ts === const o5 = { >o5 : Symbol(o5, Decl(O5.ts, 0, 5)) @@ -50,7 +50,7 @@ const o5 = { >x : Symbol(x, Decl(O5.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O6.ts === const o6 = { >o6 : Symbol(o6, Decl(O6.ts, 0, 5)) @@ -61,7 +61,7 @@ const o6 = { >x : Symbol(x, Decl(O6.ts, 2, 13)) } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O7.ts === const o7 = { >o7 : Symbol(o7, Decl(O7.ts, 0, 5)) diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types similarity index 80% rename from tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.types rename to tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types index a05b5326b2c..4b33425a7a4 100644 --- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.esnext.types +++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O1.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O1.ts === const o1 = { >o1 : { f(): AsyncIterableIterator; } >{ async * f() { }} : { f(): AsyncIterableIterator; } @@ -7,7 +7,7 @@ const o1 = { >f : () => AsyncIterableIterator } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O2.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O2.ts === const o2 = { >o2 : { f(): AsyncIterableIterator; } >{ async * f() { const x = yield; }} : { f(): AsyncIterableIterator; } @@ -20,7 +20,7 @@ const o2 = { >yield : any } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O3.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O3.ts === const o3 = { >o3 : { f(): AsyncIterableIterator; } >{ async * f() { const x = yield 1; }} : { f(): AsyncIterableIterator; } @@ -34,7 +34,7 @@ const o3 = { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O4.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O4.ts === const o4 = { >o4 : { f(): AsyncIterableIterator; } >{ async * f() { const x = yield* [1]; }} : { f(): AsyncIterableIterator; } @@ -49,7 +49,7 @@ const o4 = { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O5.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O5.ts === const o5 = { >o5 : { f(): AsyncIterableIterator; } >{ async * f() { const x = yield* (async function*() { yield 1; })(); }} : { f(): AsyncIterableIterator; } @@ -67,7 +67,7 @@ const o5 = { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O6.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O6.ts === const o6 = { >o6 : { f(): AsyncIterableIterator; } >{ async * f() { const x = await 1; }} : { f(): AsyncIterableIterator; } @@ -81,7 +81,7 @@ const o6 = { >1 : 1 } } -=== tests/cases/conformance/emitter/esnext/asyncGenerators/O7.ts === +=== tests/cases/conformance/emitter/es2018/asyncGenerators/O7.ts === const o7 = { >o7 : { f(): AsyncIterableIterator; } >{ async * f() { return 1; }} : { f(): AsyncIterableIterator; } diff --git a/tests/baselines/reference/emitter.forAwait.esnext.js b/tests/baselines/reference/emitter.forAwait.es2018.js similarity index 90% rename from tests/baselines/reference/emitter.forAwait.esnext.js rename to tests/baselines/reference/emitter.forAwait.es2018.js index 0042ae38fbd..f9ae2b1bd95 100644 --- a/tests/baselines/reference/emitter.forAwait.esnext.js +++ b/tests/baselines/reference/emitter.forAwait.es2018.js @@ -1,4 +1,4 @@ -//// [tests/cases/conformance/emitter/esnext/forAwait/emitter.forAwait.esnext.ts] //// +//// [tests/cases/conformance/emitter/es2018/forAwait/emitter.forAwait.es2018.ts] //// //// [file1.ts] async function f1() { @@ -39,7 +39,8 @@ async function* f6() { outer: for await (const x of y) { continue outer; } -} +} + //// [file1.js] async function f1() { diff --git a/tests/baselines/reference/emitter.forAwait.esnext.symbols b/tests/baselines/reference/emitter.forAwait.es2018.symbols similarity index 77% rename from tests/baselines/reference/emitter.forAwait.esnext.symbols rename to tests/baselines/reference/emitter.forAwait.es2018.symbols index 2910738102b..c1beab7fb78 100644 --- a/tests/baselines/reference/emitter.forAwait.esnext.symbols +++ b/tests/baselines/reference/emitter.forAwait.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/forAwait/file1.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file1.ts === async function f1() { >f1 : Symbol(f1, Decl(file1.ts, 0, 0)) @@ -10,7 +10,7 @@ async function f1() { >y : Symbol(y, Decl(file1.ts, 1, 7)) } } -=== tests/cases/conformance/emitter/esnext/forAwait/file2.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file2.ts === async function f2() { >f2 : Symbol(f2, Decl(file2.ts, 0, 0)) @@ -23,7 +23,7 @@ async function f2() { >y : Symbol(y, Decl(file2.ts, 1, 15)) } } -=== tests/cases/conformance/emitter/esnext/forAwait/file3.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file3.ts === async function* f3() { >f3 : Symbol(f3, Decl(file3.ts, 0, 0)) @@ -35,7 +35,7 @@ async function* f3() { >y : Symbol(y, Decl(file3.ts, 1, 7)) } } -=== tests/cases/conformance/emitter/esnext/forAwait/file4.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file4.ts === async function* f4() { >f4 : Symbol(f4, Decl(file4.ts, 0, 0)) @@ -48,7 +48,7 @@ async function* f4() { >y : Symbol(y, Decl(file4.ts, 1, 15)) } } -=== tests/cases/conformance/emitter/esnext/forAwait/file5.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file5.ts === // https://github.com/Microsoft/TypeScript/issues/21363 async function f5() { >f5 : Symbol(f5, Decl(file5.ts, 0, 0)) @@ -63,7 +63,7 @@ async function f5() { continue outer; } } -=== tests/cases/conformance/emitter/esnext/forAwait/file6.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file6.ts === // https://github.com/Microsoft/TypeScript/issues/21363 async function* f6() { >f6 : Symbol(f6, Decl(file6.ts, 0, 0)) @@ -78,3 +78,4 @@ async function* f6() { continue outer; } } + diff --git a/tests/baselines/reference/emitter.forAwait.esnext.types b/tests/baselines/reference/emitter.forAwait.es2018.types similarity index 69% rename from tests/baselines/reference/emitter.forAwait.esnext.types rename to tests/baselines/reference/emitter.forAwait.es2018.types index 6339aeebeff..c9954de364d 100644 --- a/tests/baselines/reference/emitter.forAwait.esnext.types +++ b/tests/baselines/reference/emitter.forAwait.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/emitter/esnext/forAwait/file1.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file1.ts === async function f1() { >f1 : () => Promise @@ -10,7 +10,7 @@ async function f1() { >y : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file2.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file2.ts === async function f2() { >f2 : () => Promise @@ -23,7 +23,7 @@ async function f2() { >y : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file3.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file3.ts === async function* f3() { >f3 : () => AsyncIterableIterator @@ -35,7 +35,7 @@ async function* f3() { >y : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file4.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file4.ts === async function* f4() { >f4 : () => AsyncIterableIterator @@ -48,7 +48,7 @@ async function* f4() { >y : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file5.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file5.ts === // https://github.com/Microsoft/TypeScript/issues/21363 async function f5() { >f5 : () => Promise @@ -65,7 +65,7 @@ async function f5() { >outer : any } } -=== tests/cases/conformance/emitter/esnext/forAwait/file6.ts === +=== tests/cases/conformance/emitter/es2018/forAwait/file6.ts === // https://github.com/Microsoft/TypeScript/issues/21363 async function* f6() { >f6 : () => AsyncIterableIterator @@ -82,3 +82,4 @@ async function* f6() { >outer : any } } + diff --git a/tests/baselines/reference/forAwaitForUnion.js b/tests/baselines/reference/forAwaitForUnion.js index e0a4b9ebf82..072d45967d8 100644 --- a/tests/baselines/reference/forAwaitForUnion.js +++ b/tests/baselines/reference/forAwaitForUnion.js @@ -2,7 +2,8 @@ async function f(source: Iterable | AsyncIterable) { for await (const x of source) { } -} +} + //// [forAwaitForUnion.js] async function f(source) { diff --git a/tests/baselines/reference/forAwaitForUnion.symbols b/tests/baselines/reference/forAwaitForUnion.symbols index 8b31ea48684..386cc725a12 100644 --- a/tests/baselines/reference/forAwaitForUnion.symbols +++ b/tests/baselines/reference/forAwaitForUnion.symbols @@ -13,3 +13,4 @@ async function f(source: Iterable | AsyncIterable) { >source : Symbol(source, Decl(forAwaitForUnion.ts, 0, 20)) } } + diff --git a/tests/baselines/reference/forAwaitForUnion.types b/tests/baselines/reference/forAwaitForUnion.types index 9013ce41191..180197b26ea 100644 --- a/tests/baselines/reference/forAwaitForUnion.types +++ b/tests/baselines/reference/forAwaitForUnion.types @@ -8,3 +8,4 @@ async function f(source: Iterable | AsyncIterable) { >source : Iterable | AsyncIterable } } + diff --git a/tests/baselines/reference/forwardDeclaredCommonTypes01.errors.txt b/tests/baselines/reference/forwardDeclaredCommonTypes01.errors.txt new file mode 100644 index 00000000000..59a3a7313aa --- /dev/null +++ b/tests/baselines/reference/forwardDeclaredCommonTypes01.errors.txt @@ -0,0 +1,40 @@ +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(9,9): error TS2585: 'Promise' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(10,9): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(10,17): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(11,9): error TS2585: 'Map' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(12,9): error TS2585: 'WeakMap' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(13,9): error TS2585: 'Set' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. +tests/cases/compiler/forwardDeclaredCommonTypes01.ts(14,9): error TS2585: 'WeakSet' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + + +==== tests/cases/compiler/forwardDeclaredCommonTypes01.ts (7 errors) ==== + interface Promise {} + interface Symbol {} + interface Map {} + interface WeakMap {} + interface Set {} + interface WeakSet {} + + (function() { + new Promise; + ~~~~~~~ +!!! error TS2585: 'Promise' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new Symbol; Symbol(); + ~~~~~~ +!!! error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + ~~~~~~ +!!! error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new Map; + ~~~ +!!! error TS2585: 'Map' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new WeakMap; + ~~~~~~~ +!!! error TS2585: 'WeakMap' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new Set; + ~~~ +!!! error TS2585: 'Set' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + new WeakSet; + ~~~~~~~ +!!! error TS2585: 'WeakSet' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later. + }); + \ No newline at end of file diff --git a/tests/baselines/reference/forwardDeclaredCommonTypes01.js b/tests/baselines/reference/forwardDeclaredCommonTypes01.js new file mode 100644 index 00000000000..51778524430 --- /dev/null +++ b/tests/baselines/reference/forwardDeclaredCommonTypes01.js @@ -0,0 +1,28 @@ +//// [forwardDeclaredCommonTypes01.ts] +interface Promise {} +interface Symbol {} +interface Map {} +interface WeakMap {} +interface Set {} +interface WeakSet {} + +(function() { + new Promise; + new Symbol; Symbol(); + new Map; + new WeakMap; + new Set; + new WeakSet; +}); + + +//// [forwardDeclaredCommonTypes01.js] +(function () { + new Promise; + new Symbol; + Symbol(); + new Map; + new WeakMap; + new Set; + new WeakSet; +}); diff --git a/tests/baselines/reference/forwardDeclaredCommonTypes01.symbols b/tests/baselines/reference/forwardDeclaredCommonTypes01.symbols new file mode 100644 index 00000000000..427bf4c39fb --- /dev/null +++ b/tests/baselines/reference/forwardDeclaredCommonTypes01.symbols @@ -0,0 +1,35 @@ +=== tests/cases/compiler/forwardDeclaredCommonTypes01.ts === +interface Promise {} +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(forwardDeclaredCommonTypes01.ts, 0, 0)) +>T : Symbol(T, Decl(lib.es5.d.ts, --, --), Decl(forwardDeclaredCommonTypes01.ts, 0, 18)) + +interface Symbol {} +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(forwardDeclaredCommonTypes01.ts, 0, 23)) + +interface Map {} +>Map : Symbol(Map, Decl(forwardDeclaredCommonTypes01.ts, 1, 19)) +>K : Symbol(K, Decl(forwardDeclaredCommonTypes01.ts, 2, 14)) +>V : Symbol(V, Decl(forwardDeclaredCommonTypes01.ts, 2, 16)) + +interface WeakMap {} +>WeakMap : Symbol(WeakMap, Decl(forwardDeclaredCommonTypes01.ts, 2, 22)) +>K : Symbol(K, Decl(forwardDeclaredCommonTypes01.ts, 3, 18)) +>V : Symbol(V, Decl(forwardDeclaredCommonTypes01.ts, 3, 35)) + +interface Set {} +>Set : Symbol(Set, Decl(forwardDeclaredCommonTypes01.ts, 3, 41)) +>T : Symbol(T, Decl(forwardDeclaredCommonTypes01.ts, 4, 14)) + +interface WeakSet {} +>WeakSet : Symbol(WeakSet, Decl(forwardDeclaredCommonTypes01.ts, 4, 19)) +>T : Symbol(T, Decl(forwardDeclaredCommonTypes01.ts, 5, 18)) + +(function() { + new Promise; + new Symbol; Symbol(); + new Map; + new WeakMap; + new Set; + new WeakSet; +}); + diff --git a/tests/baselines/reference/forwardDeclaredCommonTypes01.types b/tests/baselines/reference/forwardDeclaredCommonTypes01.types new file mode 100644 index 00000000000..279b772d7d5 --- /dev/null +++ b/tests/baselines/reference/forwardDeclaredCommonTypes01.types @@ -0,0 +1,40 @@ +=== tests/cases/compiler/forwardDeclaredCommonTypes01.ts === +interface Promise {} +interface Symbol {} +interface Map {} +interface WeakMap {} +interface Set {} +interface WeakSet {} + +(function() { +>(function() { new Promise; new Symbol; Symbol(); new Map; new WeakMap; new Set; new WeakSet;}) : () => void +>function() { new Promise; new Symbol; Symbol(); new Map; new WeakMap; new Set; new WeakSet;} : () => void + + new Promise; +>new Promise : any +>Promise : any + + new Symbol; Symbol(); +>new Symbol : any +>Symbol : any +>Symbol() : any +>Symbol : any + + new Map; +>new Map : any +>Map : any + + new WeakMap; +>new WeakMap : any +>WeakMap : any + + new Set; +>new Set : any +>Set : any + + new WeakSet; +>new WeakSet : any +>WeakSet : any + +}); + diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt index 642e38cc6e0..6deae7b10e1 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.errors.txt @@ -1,8 +1,9 @@ -tests/cases/compiler/file1.ts(1,20): error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. +tests/cases/compiler/file1.ts(2,16): error TS2748: Cannot access ambient const enums when the '--isolatedModules' flag is provided. ==== tests/cases/compiler/file1.ts (1 errors) ==== declare const enum E { X = 1} - ~ -!!! error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided. - export var y; \ No newline at end of file + export var y = E.X; + ~ +!!! error TS2748: Cannot access ambient const enums when the '--isolatedModules' flag is provided. + \ No newline at end of file diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.js b/tests/baselines/reference/isolatedModulesAmbientConstEnum.js index 44b6e1c1d76..2977c8ab827 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.js +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.js @@ -1,6 +1,7 @@ //// [file1.ts] declare const enum E { X = 1} -export var y; +export var y = E.X; + //// [file1.js] -export var y; +export var y = E.X; diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.symbols b/tests/baselines/reference/isolatedModulesAmbientConstEnum.symbols index 2da04dbdf02..828f79379b1 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.symbols +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.symbols @@ -3,6 +3,9 @@ declare const enum E { X = 1} >E : Symbol(E, Decl(file1.ts, 0, 0)) >X : Symbol(E.X, Decl(file1.ts, 0, 22)) -export var y; +export var y = E.X; >y : Symbol(y, Decl(file1.ts, 1, 10)) +>E.X : Symbol(E.X, Decl(file1.ts, 0, 22)) +>E : Symbol(E, Decl(file1.ts, 0, 0)) +>X : Symbol(E.X, Decl(file1.ts, 0, 22)) diff --git a/tests/baselines/reference/isolatedModulesAmbientConstEnum.types b/tests/baselines/reference/isolatedModulesAmbientConstEnum.types index 8b714d98f6e..bb4212895f9 100644 --- a/tests/baselines/reference/isolatedModulesAmbientConstEnum.types +++ b/tests/baselines/reference/isolatedModulesAmbientConstEnum.types @@ -4,6 +4,9 @@ declare const enum E { X = 1} >X : E.X >1 : 1 -export var y; ->y : any +export var y = E.X; +>y : E +>E.X : E +>E : typeof E +>X : E diff --git a/tests/baselines/reference/jsdocAugments_noExtends.errors.txt b/tests/baselines/reference/jsdocAugments_noExtends.errors.txt new file mode 100644 index 00000000000..036f30301f9 --- /dev/null +++ b/tests/baselines/reference/jsdocAugments_noExtends.errors.txt @@ -0,0 +1,15 @@ +/b.js(6,21): error TS2339: Property 'x' does not exist on type 'B'. + + +==== /b.js (1 errors) ==== + class A { constructor() { this.x = 0; } } + + /** @augments A */ + class B { + m() { + return this.x; + ~ +!!! error TS2339: Property 'x' does not exist on type 'B'. + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/jsdocAugments_noExtends.symbols b/tests/baselines/reference/jsdocAugments_noExtends.symbols index cd3d8575f26..2303e600979 100644 --- a/tests/baselines/reference/jsdocAugments_noExtends.symbols +++ b/tests/baselines/reference/jsdocAugments_noExtends.symbols @@ -13,9 +13,7 @@ class B { >m : Symbol(B.m, Decl(b.js, 3, 9)) return this.x; ->this.x : Symbol(A.x, Decl(b.js, 0, 25)) >this : Symbol(B, Decl(b.js, 0, 41)) ->x : Symbol(A.x, Decl(b.js, 0, 25)) } } diff --git a/tests/baselines/reference/jsdocAugments_noExtends.types b/tests/baselines/reference/jsdocAugments_noExtends.types index 5a2c5632ab7..fab9c7b7c84 100644 --- a/tests/baselines/reference/jsdocAugments_noExtends.types +++ b/tests/baselines/reference/jsdocAugments_noExtends.types @@ -12,12 +12,12 @@ class B { >B : B m() { ->m : () => number +>m : () => any return this.x; ->this.x : number +>this.x : any >this : this ->x : number +>x : any } } diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.errors.txt similarity index 68% rename from tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.errors.txt rename to tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.errors.txt index febd6d1160e..0a114efc26c 100644 --- a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.errors.txt +++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.errors.txt @@ -1,50 +1,50 @@ -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts(2,17): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts(2,15): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts(2,17): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts(2,19): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts(3,14): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,15): error TS2693: 'await' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,20): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,18): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,24): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,26): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,18): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,26): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,28): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,34): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,36): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,28): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,36): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsStrictError.ts(4,16): error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts(2,14): error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts(2,14): error TS2693: 'yield' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS1163: A 'yield' expression is only allowed in a generator body. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,15): error TS2693: 'yield' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,20): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts(3,16): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts(2,17): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts(2,15): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts(2,17): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts(2,19): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts(3,14): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,15): error TS2693: 'await' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,20): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,18): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,24): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,26): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,18): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,26): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,28): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,34): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,36): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,28): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,36): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsStrictError.ts(4,16): error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts(2,14): error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts(2,14): error TS2693: 'yield' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS1163: A 'yield' expression is only allowed in a generator body. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS2523: 'yield' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,15): error TS2693: 'yield' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,20): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts(3,16): error TS1109: Expression expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts (0 errors) ==== class C1 { async * f() { } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== class C2 { async * await() { } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== class C3 { async * yield() { } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (4 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts (4 errors) ==== class C4 { async * f(await) { ~~~~~ @@ -57,7 +57,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } ~ !!! error TS1128: Declaration or statement expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (4 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts (4 errors) ==== class C5 { async * f(yield) { ~~~~~ @@ -70,14 +70,14 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } ~ !!! error TS1128: Declaration or statement expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== class C6 { async * f(a = await 1) { ~~~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts (2 errors) ==== class C7 { async * f(a = yield) { ~~~~~ @@ -86,14 +86,14 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== class C8 { async * f() { async function * g() { } } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== class C9 { async * f() { function yield() { @@ -104,7 +104,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== class C10 { async * f() { const x = function yield() { @@ -115,7 +115,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== class C11 { async * f() { function await() { @@ -128,7 +128,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== class C12 { async * f() { const x = function await() { @@ -141,19 +141,19 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts (0 errors) ==== class C13 { async * f() { yield; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== class C14 { async * f() { yield 1; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== class C15 { async * f() { yield *; @@ -161,19 +161,19 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1109: Expression expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== class C16 { async * f() { yield * []; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== class C17 { async * f() { await 1; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== class C18 { async * f() { await; @@ -181,14 +181,14 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1109: Expression expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== interface await {} class C19 { async * f() { let x: await; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsStrictError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsStrictError.ts (1 errors) ==== interface yield {} class C20 { async * f() { @@ -197,7 +197,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1213: Identifier expected. 'yield' is a reserved word in strict mode. Class definitions are automatically in strict mode. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts (2 errors) ==== class C21 { async * [yield]() { ~~~~~ @@ -206,13 +206,13 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS2693: 'yield' only refers to a type, but is being used as a value here. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== class C22 { async * f() { const x = { [yield]: 1 }; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== class C23 { async * get x() { ~ @@ -220,16 +220,17 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa return 1; } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts (1 errors) ==== class C24 { async * set x(value: number) { ~ !!! error TS1005: '(' expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts (1 errors) ==== class C25 { async * x = 1; ~ !!! error TS1005: '(' expected. - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.symbols b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.symbols similarity index 78% rename from tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.symbols rename to tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.symbols index 30e2ed3df59..b3494dd0079 100644 --- a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.symbols +++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts === class C1 { >C1 : Symbol(C1, Decl(methodIsOk.ts, 0, 0)) @@ -6,7 +6,7 @@ class C1 { >f : Symbol(C1.f, Decl(methodIsOk.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts === class C2 { >C2 : Symbol(C2, Decl(awaitMethodNameIsOk.ts, 0, 0)) @@ -14,7 +14,7 @@ class C2 { >await : Symbol(C2.await, Decl(awaitMethodNameIsOk.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts === class C3 { >C3 : Symbol(C3, Decl(yieldMethodNameIsOk.ts, 0, 0)) @@ -22,7 +22,7 @@ class C3 { >yield : Symbol(C3.yield, Decl(yieldMethodNameIsOk.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === class C4 { >C4 : Symbol(C4, Decl(awaitParameterIsError.ts, 0, 0)) @@ -30,7 +30,7 @@ class C4 { >f : Symbol(C4.f, Decl(awaitParameterIsError.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === class C5 { >C5 : Symbol(C5, Decl(yieldParameterIsError.ts, 0, 0)) @@ -38,7 +38,7 @@ class C5 { >f : Symbol(C5.f, Decl(yieldParameterIsError.ts, 0, 10)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === class C6 { >C6 : Symbol(C6, Decl(awaitInParameterInitializerIsError.ts, 0, 0)) @@ -47,7 +47,7 @@ class C6 { >a : Symbol(a, Decl(awaitInParameterInitializerIsError.ts, 1, 14)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === class C7 { >C7 : Symbol(C7, Decl(yieldInParameterInitializerIsError.ts, 0, 0)) @@ -56,7 +56,7 @@ class C7 { >a : Symbol(a, Decl(yieldInParameterInitializerIsError.ts, 1, 14)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === class C8 { >C8 : Symbol(C8, Decl(nestedAsyncGeneratorIsOk.ts, 0, 0)) @@ -68,7 +68,7 @@ class C8 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === class C9 { >C9 : Symbol(C9, Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 0)) @@ -80,7 +80,7 @@ class C9 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === class C10 { >C10 : Symbol(C10, Decl(nestedFunctionExpressionNamedYieldIsError.ts, 0, 0)) @@ -93,7 +93,7 @@ class C10 { }; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === class C11 { >C11 : Symbol(C11, Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 0)) @@ -105,7 +105,7 @@ class C11 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === class C12 { >C12 : Symbol(C12, Decl(nestedFunctionExpressionNamedAwaitIsError.ts, 0, 0)) @@ -118,7 +118,7 @@ class C12 { }; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === class C13 { >C13 : Symbol(C13, Decl(yieldIsOk.ts, 0, 0)) @@ -128,7 +128,7 @@ class C13 { yield; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === class C14 { >C14 : Symbol(C14, Decl(yieldWithValueIsOk.ts, 0, 0)) @@ -138,7 +138,7 @@ class C14 { yield 1; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === class C15 { >C15 : Symbol(C15, Decl(yieldStarMissingValueIsError.ts, 0, 0)) @@ -148,7 +148,7 @@ class C15 { yield *; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === class C16 { >C16 : Symbol(C16, Decl(yieldStarWithValueIsOk.ts, 0, 0)) @@ -158,7 +158,7 @@ class C16 { yield * []; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === class C17 { >C17 : Symbol(C17, Decl(awaitWithValueIsOk.ts, 0, 0)) @@ -168,7 +168,7 @@ class C17 { await 1; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === class C18 { >C18 : Symbol(C18, Decl(awaitMissingValueIsError.ts, 0, 0)) @@ -178,7 +178,7 @@ class C18 { await; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} >await : Symbol(await, Decl(awaitAsTypeIsOk.ts, 0, 0)) @@ -193,7 +193,7 @@ class C19 { >await : Symbol(await, Decl(awaitAsTypeIsOk.ts, 0, 0)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsStrictError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsStrictError.ts === interface yield {} >yield : Symbol(yield, Decl(yieldAsTypeIsStrictError.ts, 0, 0)) @@ -208,7 +208,7 @@ class C20 { >yield : Symbol(yield, Decl(yieldAsTypeIsStrictError.ts, 0, 0)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts === class C21 { >C21 : Symbol(C21, Decl(yieldInClassComputedPropertyIsError.ts, 0, 0)) @@ -216,7 +216,7 @@ class C21 { >[yield] : Symbol(C21[yield], Decl(yieldInClassComputedPropertyIsError.ts, 0, 11)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === class C22 { >C22 : Symbol(C22, Decl(yieldInNestedComputedPropertyIsOk.ts, 0, 0)) @@ -228,7 +228,7 @@ class C22 { >[yield] : Symbol([yield], Decl(yieldInNestedComputedPropertyIsOk.ts, 2, 19)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === class C23 { >C23 : Symbol(C23, Decl(asyncGeneratorGetAccessorIsError.ts, 0, 0)) @@ -239,7 +239,7 @@ class C23 { return 1; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === class C24 { >C24 : Symbol(C24, Decl(asyncGeneratorSetAccessorIsError.ts, 0, 0)) @@ -249,7 +249,7 @@ class C24 { >value : Symbol(value, Decl(asyncGeneratorSetAccessorIsError.ts, 1, 18)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts === class C25 { >C25 : Symbol(C25, Decl(asyncGeneratorPropertyIsError.ts, 0, 0)) @@ -257,3 +257,4 @@ class C25 { >x : Symbol(C25.x, Decl(asyncGeneratorPropertyIsError.ts, 0, 11)) >1 : Symbol(C25[1], Decl(asyncGeneratorPropertyIsError.ts, 1, 15)) } + diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.types b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types similarity index 69% rename from tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.types rename to tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types index a6662a10d43..9252c2a22c1 100644 --- a/tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.types +++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts === class C1 { >C1 : C1 @@ -6,7 +6,7 @@ class C1 { >f : () => AsyncIterableIterator } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts === class C2 { >C2 : C2 @@ -14,7 +14,7 @@ class C2 { >await : () => AsyncIterableIterator } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts === class C3 { >C3 : C3 @@ -22,7 +22,7 @@ class C3 { >yield : () => AsyncIterableIterator } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === class C4 { >C4 : C4 @@ -31,7 +31,7 @@ class C4 { >await : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === class C5 { >C5 : C5 @@ -40,7 +40,7 @@ class C5 { >yield : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === class C6 { >C6 : C6 @@ -51,7 +51,7 @@ class C6 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === class C7 { >C7 : C7 @@ -61,7 +61,7 @@ class C7 { >yield : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === class C8 { >C8 : C8 @@ -73,7 +73,7 @@ class C8 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === class C9 { >C9 : C9 @@ -87,7 +87,7 @@ class C9 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === class C10 { >C10 : C10 @@ -103,7 +103,7 @@ class C10 { }; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === class C11 { >C11 : C11 @@ -118,7 +118,7 @@ class C11 { } } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === class C12 { >C12 : C12 @@ -135,7 +135,7 @@ class C12 { }; } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === class C13 { >C13 : C13 @@ -146,7 +146,7 @@ class C13 { >yield : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === class C14 { >C14 : C14 @@ -158,7 +158,7 @@ class C14 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === class C15 { >C15 : C15 @@ -170,7 +170,7 @@ class C15 { > : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === class C16 { >C16 : C16 @@ -182,7 +182,7 @@ class C16 { >[] : undefined[] } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === class C17 { >C17 : C17 @@ -194,7 +194,7 @@ class C17 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === class C18 { >C18 : C18 @@ -206,7 +206,7 @@ class C18 { > : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} class C19 { >C19 : C19 @@ -218,7 +218,7 @@ class C19 { >x : await } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsStrictError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsStrictError.ts === interface yield {} class C20 { >C20 : C20 @@ -230,7 +230,7 @@ class C20 { >x : yield } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInClassComputedPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInClassComputedPropertyIsError.ts === class C21 { >C21 : C21 @@ -239,7 +239,7 @@ class C21 { >yield : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === class C22 { >C22 : C22 @@ -254,7 +254,7 @@ class C22 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === class C23 { >C23 : C23 @@ -266,7 +266,7 @@ class C23 { >1 : 1 } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === class C24 { >C24 : C24 @@ -276,7 +276,7 @@ class C24 { >value : number } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts === class C25 { >C25 : C25 @@ -284,3 +284,4 @@ class C25 { >x : () => any >1 : any } + diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.errors.txt similarity index 65% rename from tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.errors.txt rename to tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.errors.txt index a80c67badd5..bc020c474df 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.errors.txt +++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.errors.txt @@ -1,61 +1,61 @@ -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts(1,25): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts(2,10): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,21): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,26): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,20): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,22): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,22): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,24): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,32): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,24): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,32): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(1,25): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,21): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,26): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts(2,12): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts(1,25): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts(2,10): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,21): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,26): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,14): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,20): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,22): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,14): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,22): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,24): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,32): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,24): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,32): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(1,25): error TS2523: 'yield' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,21): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,26): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts(2,12): error TS1109: Expression expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionDeclarationIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionDeclarationIsOk.ts (0 errors) ==== async function * f1() { } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsOk.ts (0 errors) ==== async function * await() { } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsOk.ts (0 errors) ==== async function * yield() { } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts (2 errors) ==== async function * f4(await) { ~~~~~ !!! error TS1138: Parameter declaration expected. ~ !!! error TS1005: ';' expected. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts (2 errors) ==== async function * f5(yield) { ~~~~~ !!! error TS1138: Parameter declaration expected. ~ !!! error TS1005: ';' expected. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== async function * f6(a = await 1) { ~~~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== async function * f7(a = yield) { ~~~~~ !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== async function * f8() { async function * g() { } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== async function * f9() { function yield() { ~~~~~ @@ -64,7 +64,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== async function * f10() { const x = function yield() { ~~~~~ @@ -73,7 +73,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. }; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== async function * f11() { function await() { ~~~~~ @@ -84,7 +84,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: ';' expected. } } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (2 errors) ==== async function * f12() { const x = function yield() { ~~~~~ @@ -93,45 +93,46 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. }; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts (0 errors) ==== async function * f13() { yield; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== async function * f14() { yield 1; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== async function * f15() { yield *; ~ !!! error TS1109: Expression expected. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== async function * f16() { yield * []; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== async function * f17() { await 1; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== async function * f18() { await; ~ !!! error TS1109: Expression expected. } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== interface await {} async function * f19() { let x: await; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== interface yield {} async function * f20() { let x: yield; } -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== async function * f21() { const x = { [yield]: 1 }; - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.symbols b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.symbols similarity index 74% rename from tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.symbols rename to tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.symbols index f8359754d6f..cfc9034846c 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.symbols +++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.symbols @@ -1,36 +1,36 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionDeclarationIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionDeclarationIsOk.ts === async function * f1() { >f1 : Symbol(f1, Decl(functionDeclarationIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsOk.ts === async function * await() { >await : Symbol(await, Decl(awaitNameIsOk.ts, 0, 0), Decl(awaitAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsOk.ts === async function * yield() { >yield : Symbol(yield, Decl(yieldNameIsOk.ts, 0, 0), Decl(yieldAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === async function * f4(await) { >f4 : Symbol(f4, Decl(awaitParameterIsError.ts, 0, 0)) >await : Symbol(await, Decl(awaitNameIsOk.ts, 0, 0), Decl(awaitAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === async function * f5(yield) { >f5 : Symbol(f5, Decl(yieldParameterIsError.ts, 0, 0)) >yield : Symbol(yield, Decl(yieldNameIsOk.ts, 0, 0), Decl(yieldAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === async function * f6(a = await 1) { >f6 : Symbol(f6, Decl(awaitInParameterInitializerIsError.ts, 0, 0)) >a : Symbol(a, Decl(awaitInParameterInitializerIsError.ts, 0, 20)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === async function * f7(a = yield) { >f7 : Symbol(f7, Decl(yieldInParameterInitializerIsError.ts, 0, 0)) >a : Symbol(a, Decl(yieldInParameterInitializerIsError.ts, 0, 20)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === async function * f8() { >f8 : Symbol(f8, Decl(nestedAsyncGeneratorIsOk.ts, 0, 0)) @@ -38,7 +38,7 @@ async function * f8() { >g : Symbol(g, Decl(nestedAsyncGeneratorIsOk.ts, 0, 23)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === async function * f9() { >f9 : Symbol(f9, Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 0)) @@ -46,7 +46,7 @@ async function * f9() { > : Symbol((Missing), Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 23)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === async function * f10() { >f10 : Symbol(f10, Decl(nestedFunctionExpressionNamedYieldIsError.ts, 0, 0)) @@ -55,7 +55,7 @@ async function * f10() { }; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === async function * f11() { >f11 : Symbol(f11, Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 0)) @@ -63,7 +63,7 @@ async function * f11() { > : Symbol((Missing), Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 24)) } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === async function * f12() { >f12 : Symbol(f12, Decl(nestedFunctionExpressionNamedAwaitIsError.ts, 0, 0)) @@ -72,43 +72,43 @@ async function * f12() { }; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === async function * f13() { >f13 : Symbol(f13, Decl(yieldIsOk.ts, 0, 0)) yield; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === async function * f14() { >f14 : Symbol(f14, Decl(yieldWithValueIsOk.ts, 0, 0)) yield 1; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === async function * f15() { >f15 : Symbol(f15, Decl(yieldStarMissingValueIsError.ts, 0, 0)) yield *; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === async function * f16() { >f16 : Symbol(f16, Decl(yieldStarWithValueIsOk.ts, 0, 0)) yield * []; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === async function * f17() { >f17 : Symbol(f17, Decl(awaitWithValueIsOk.ts, 0, 0)) await 1; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === async function * f18() { >f18 : Symbol(f18, Decl(awaitMissingValueIsError.ts, 0, 0)) await; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} >await : Symbol(await, Decl(awaitNameIsOk.ts, 0, 0), Decl(awaitAsTypeIsOk.ts, 0, 0)) @@ -119,7 +119,7 @@ async function * f19() { >x : Symbol(x, Decl(awaitAsTypeIsOk.ts, 2, 7)) >await : Symbol(await, Decl(awaitNameIsOk.ts, 0, 0), Decl(awaitAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} >yield : Symbol(yield, Decl(yieldNameIsOk.ts, 0, 0), Decl(yieldAsTypeIsOk.ts, 0, 0)) @@ -130,7 +130,7 @@ async function * f20() { >x : Symbol(x, Decl(yieldAsTypeIsOk.ts, 2, 7)) >yield : Symbol(yield, Decl(yieldNameIsOk.ts, 0, 0), Decl(yieldAsTypeIsOk.ts, 0, 0)) } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === async function * f21() { >f21 : Symbol(f21, Decl(yieldInNestedComputedPropertyIsOk.ts, 0, 0)) @@ -138,3 +138,4 @@ async function * f21() { >x : Symbol(x, Decl(yieldInNestedComputedPropertyIsOk.ts, 1, 9)) >[yield] : Symbol([yield], Decl(yieldInNestedComputedPropertyIsOk.ts, 1, 15)) } + diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.types b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types similarity index 68% rename from tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.types rename to tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types index 5d3c28b9f9e..8804529efd2 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.types +++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types @@ -1,39 +1,39 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionDeclarationIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionDeclarationIsOk.ts === async function * f1() { >f1 : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsOk.ts === async function * await() { >await : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsOk.ts === async function * yield() { >yield : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === async function * f4(await) { >f4 : () => any >await : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === async function * f5(yield) { >f5 : () => any >yield : () => AsyncIterableIterator } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === async function * f6(a = await 1) { >f6 : (a?: number) => AsyncIterableIterator >a : number >await 1 : 1 >1 : 1 } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === async function * f7(a = yield) { >f7 : (a?: any) => AsyncIterableIterator >a : any >yield : any } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === async function * f8() { >f8 : () => AsyncIterableIterator @@ -41,7 +41,7 @@ async function * f8() { >g : () => AsyncIterableIterator } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === async function * f9() { >f9 : () => AsyncIterableIterator<() => void> @@ -51,7 +51,7 @@ async function * f9() { >() { } : () => void } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === async function * f10() { >f10 : () => AsyncIterableIterator<() => void> @@ -63,7 +63,7 @@ async function * f10() { }; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === async function * f11() { >f11 : () => AsyncIterableIterator @@ -74,7 +74,7 @@ async function * f11() { > : any } } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === async function * f12() { >f12 : () => AsyncIterableIterator<() => void> @@ -86,14 +86,14 @@ async function * f12() { }; } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === async function * f13() { >f13 : () => AsyncIterableIterator yield; >yield : any } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === async function * f14() { >f14 : () => AsyncIterableIterator @@ -101,7 +101,7 @@ async function * f14() { >yield 1 : any >1 : 1 } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === async function * f15() { >f15 : () => AsyncIterableIterator @@ -109,7 +109,7 @@ async function * f15() { >yield * : any > : any } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === async function * f16() { >f16 : () => AsyncIterableIterator @@ -117,7 +117,7 @@ async function * f16() { >yield * [] : any >[] : undefined[] } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === async function * f17() { >f17 : () => AsyncIterableIterator @@ -125,7 +125,7 @@ async function * f17() { >await 1 : 1 >1 : 1 } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === async function * f18() { >f18 : () => AsyncIterableIterator @@ -133,7 +133,7 @@ async function * f18() { >await : any > : any } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} async function * f19() { >f19 : () => AsyncIterableIterator @@ -141,7 +141,7 @@ async function * f19() { let x: await; >x : await } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} async function * f20() { >f20 : () => AsyncIterableIterator @@ -149,7 +149,7 @@ async function * f20() { let x: yield; >x : yield } -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === async function * f21() { >f21 : () => AsyncIterableIterator @@ -160,3 +160,4 @@ async function * f21() { >yield : any >1 : 1 } + diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.errors.txt similarity index 66% rename from tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.errors.txt rename to tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.errors.txt index f9f564f1cc2..43d2eb414b2 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.errors.txt +++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.errors.txt @@ -1,96 +1,96 @@ -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts(1,34): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts(2,10): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts(1,29): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts(1,29): error TS2451: Cannot redeclare block-scoped variable 'await'. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts(1,34): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts(1,37): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,30): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,30): error TS2451: Cannot redeclare block-scoped variable 'await'. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(1,35): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,20): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,22): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,14): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,22): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,24): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,30): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,32): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,24): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,32): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(1,34): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts(1,29): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts(1,29): error TS2451: Cannot redeclare block-scoped variable 'yield'. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts(1,34): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts(1,37): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,30): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,30): error TS2451: Cannot redeclare block-scoped variable 'yield'. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(1,35): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts(2,12): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts(1,34): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts(2,10): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts(1,29): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts(1,29): error TS2451: Cannot redeclare block-scoped variable 'await'. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts(1,34): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts(1,37): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,30): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,30): error TS2451: Cannot redeclare block-scoped variable 'await'. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(1,35): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,14): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,20): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(2,22): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,14): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(2,22): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,24): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,30): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(2,32): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,24): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(2,32): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(1,34): error TS2523: 'yield' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts(1,29): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts(1,29): error TS2451: Cannot redeclare block-scoped variable 'yield'. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts(1,34): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts(1,37): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,30): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,30): error TS2451: Cannot redeclare block-scoped variable 'yield'. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(1,35): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts(2,12): error TS1109: Expression expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionExpressionIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionExpressionIsOk.ts (0 errors) ==== const f1 = async function * f() { }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts (4 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts (4 errors) ==== const f2 = async function * await() { ~~~~~ !!! error TS1005: '(' expected. ~~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'await'. -!!! related TS6203 tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts:1:30: 'await' was also declared here. +!!! related TS6203 tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts:1:30: 'await' was also declared here. ~ !!! error TS1005: ',' expected. ~ !!! error TS1005: '=>' expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts (4 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts (4 errors) ==== const f3 = async function * yield() { ~~~~~ !!! error TS1005: '(' expected. ~~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'yield'. -!!! related TS6203 tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts:1:30: 'yield' was also declared here. +!!! related TS6203 tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts:1:30: 'yield' was also declared here. ~ !!! error TS1005: ',' expected. ~ !!! error TS1005: '=>' expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts (3 errors) ==== const f4 = async function * (await) { ~~~~~ !!! error TS1138: Parameter declaration expected. ~~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'await'. -!!! related TS6203 tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts:1:29: 'await' was also declared here. +!!! related TS6203 tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts:1:29: 'await' was also declared here. ~ !!! error TS1005: ',' expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts (3 errors) ==== const f5 = async function * (yield) { ~~~~~ !!! error TS1138: Parameter declaration expected. ~~~~~ !!! error TS2451: Cannot redeclare block-scoped variable 'yield'. -!!! related TS6203 tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts:1:29: 'yield' was also declared here. +!!! related TS6203 tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts:1:29: 'yield' was also declared here. ~ !!! error TS1005: ',' expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== const f6 = async function * (a = await 1) { ~~~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== const f7 = async function * (a = yield) { ~~~~~ !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== const f8 = async function * () { async function * g() { } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== const f9 = async function * () { function yield() { ~~~~~ @@ -99,7 +99,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== const f10 = async function * () { const x = function yield() { ~~~~~ @@ -108,7 +108,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: '=>' expected. }; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== const f11 = async function * () { function await() { ~~~~~ @@ -119,7 +119,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: ';' expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== const f12 = async function * () { const x = function await() { ~~~~~ @@ -130,45 +130,45 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1005: ';' expected. }; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts (0 errors) ==== const f13 = async function * () { yield; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== const f14 = async function * () { yield 1; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== const f15 = async function * () { yield *; ~ !!! error TS1109: Expression expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== const f16 = async function * () { yield * []; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== const f17 = async function * () { await 1; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== const f18 = async function * () { await; ~ !!! error TS1109: Expression expected. }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== interface await {} const f19 = async function * () { let x: await; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== interface yield {} const f20 = async function * () { let x: yield; }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== const f21 = async function *() { const x = { [yield]: 1 }; }; diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.symbols b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.symbols similarity index 75% rename from tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.symbols rename to tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.symbols index a22915b1533..b914ecf1eaf 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.symbols +++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.symbols @@ -1,46 +1,46 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionExpressionIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionExpressionIsOk.ts === const f1 = async function * f() { >f1 : Symbol(f1, Decl(functionExpressionIsOk.ts, 0, 5)) >f : Symbol(f, Decl(functionExpressionIsOk.ts, 0, 10)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts === const f2 = async function * await() { >f2 : Symbol(f2, Decl(awaitNameIsError.ts, 0, 5)) >await : Symbol(await, Decl(awaitNameIsError.ts, 0, 27), Decl(awaitAsTypeIsOk.ts, 0, 0)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts === const f3 = async function * yield() { >f3 : Symbol(f3, Decl(yieldNameIsError.ts, 0, 5)) >yield : Symbol(yield, Decl(yieldNameIsError.ts, 0, 27), Decl(yieldAsTypeIsOk.ts, 0, 0)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === const f4 = async function * (await) { >f4 : Symbol(f4, Decl(awaitParameterIsError.ts, 0, 5)) >await : Symbol(await, Decl(awaitParameterIsError.ts, 0, 29)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === const f5 = async function * (yield) { >f5 : Symbol(f5, Decl(yieldParameterIsError.ts, 0, 5)) >yield : Symbol(yield, Decl(yieldParameterIsError.ts, 0, 29)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === const f6 = async function * (a = await 1) { >f6 : Symbol(f6, Decl(awaitInParameterInitializerIsError.ts, 0, 5)) >a : Symbol(a, Decl(awaitInParameterInitializerIsError.ts, 0, 29)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === const f7 = async function * (a = yield) { >f7 : Symbol(f7, Decl(yieldInParameterInitializerIsError.ts, 0, 5)) >a : Symbol(a, Decl(yieldInParameterInitializerIsError.ts, 0, 29)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === const f8 = async function * () { >f8 : Symbol(f8, Decl(nestedAsyncGeneratorIsOk.ts, 0, 5)) @@ -48,7 +48,7 @@ const f8 = async function * () { >g : Symbol(g, Decl(nestedAsyncGeneratorIsOk.ts, 0, 32)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === const f9 = async function * () { >f9 : Symbol(f9, Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 5)) @@ -56,7 +56,7 @@ const f9 = async function * () { > : Symbol((Missing), Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 32)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === const f10 = async function * () { >f10 : Symbol(f10, Decl(nestedFunctionExpressionNamedYieldIsError.ts, 0, 5)) @@ -65,7 +65,7 @@ const f10 = async function * () { }; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === const f11 = async function * () { >f11 : Symbol(f11, Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 5)) @@ -73,7 +73,7 @@ const f11 = async function * () { > : Symbol((Missing), Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 33)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === const f12 = async function * () { >f12 : Symbol(f12, Decl(nestedFunctionExpressionNamedAwaitIsError.ts, 0, 5)) @@ -82,43 +82,43 @@ const f12 = async function * () { }; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === const f13 = async function * () { >f13 : Symbol(f13, Decl(yieldIsOk.ts, 0, 5)) yield; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === const f14 = async function * () { >f14 : Symbol(f14, Decl(yieldWithValueIsOk.ts, 0, 5)) yield 1; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === const f15 = async function * () { >f15 : Symbol(f15, Decl(yieldStarMissingValueIsError.ts, 0, 5)) yield *; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === const f16 = async function * () { >f16 : Symbol(f16, Decl(yieldStarWithValueIsOk.ts, 0, 5)) yield * []; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === const f17 = async function * () { >f17 : Symbol(f17, Decl(awaitWithValueIsOk.ts, 0, 5)) await 1; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === const f18 = async function * () { >f18 : Symbol(f18, Decl(awaitMissingValueIsError.ts, 0, 5)) await; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} >await : Symbol(await, Decl(awaitNameIsError.ts, 0, 27), Decl(awaitAsTypeIsOk.ts, 0, 0)) @@ -130,7 +130,7 @@ const f19 = async function * () { >await : Symbol(await, Decl(awaitNameIsError.ts, 0, 27), Decl(awaitAsTypeIsOk.ts, 0, 0)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} >yield : Symbol(yield, Decl(yieldNameIsError.ts, 0, 27), Decl(yieldAsTypeIsOk.ts, 0, 0)) @@ -142,7 +142,7 @@ const f20 = async function * () { >yield : Symbol(yield, Decl(yieldNameIsError.ts, 0, 27), Decl(yieldAsTypeIsOk.ts, 0, 0)) }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === const f21 = async function *() { >f21 : Symbol(f21, Decl(yieldInNestedComputedPropertyIsOk.ts, 0, 5)) diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.types b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types similarity index 76% rename from tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.types rename to tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types index f97176336c6..277b79a3a39 100644 --- a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.types +++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types @@ -1,11 +1,11 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/functionExpressionIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionExpressionIsOk.ts === const f1 = async function * f() { >f1 : () => AsyncIterableIterator >async function * f() {} : () => AsyncIterableIterator >f : () => AsyncIterableIterator }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitNameIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts === const f2 = async function * await() { >f2 : () => any >async function * : () => any @@ -13,7 +13,7 @@ const f2 = async function * await() { >() {} : () => void }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldNameIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsError.ts === const f3 = async function * yield() { >f3 : () => any >async function * : () => any @@ -21,21 +21,21 @@ const f3 = async function * yield() { >() {} : () => void }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === const f4 = async function * (await) { >f4 : () => any >async function * ( : () => any >await : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === const f5 = async function * (yield) { >f5 : () => any >async function * ( : () => any >yield : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === const f6 = async function * (a = await 1) { >f6 : (a?: number) => AsyncIterableIterator >async function * (a = await 1) {} : (a?: number) => AsyncIterableIterator @@ -44,7 +44,7 @@ const f6 = async function * (a = await 1) { >1 : 1 }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === const f7 = async function * (a = yield) { >f7 : (a?: any) => AsyncIterableIterator >async function * (a = yield) {} : (a?: any) => AsyncIterableIterator @@ -52,7 +52,7 @@ const f7 = async function * (a = yield) { >yield : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === const f8 = async function * () { >f8 : () => AsyncIterableIterator >async function * () { async function * g() { }} : () => AsyncIterableIterator @@ -61,7 +61,7 @@ const f8 = async function * () { >g : () => AsyncIterableIterator } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === const f9 = async function * () { >f9 : () => AsyncIterableIterator<() => void> >async function * () { function yield() { }} : () => AsyncIterableIterator<() => void> @@ -72,7 +72,7 @@ const f9 = async function * () { >() { } : () => void } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === const f10 = async function * () { >f10 : () => AsyncIterableIterator<() => void> >async function * () { const x = function yield() { };} : () => AsyncIterableIterator<() => void> @@ -85,7 +85,7 @@ const f10 = async function * () { }; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === const f11 = async function * () { >f11 : () => AsyncIterableIterator >async function * () { function await() { }} : () => AsyncIterableIterator @@ -97,7 +97,7 @@ const f11 = async function * () { > : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === const f12 = async function * () { >f12 : () => AsyncIterableIterator >async function * () { const x = function await() { };} : () => AsyncIterableIterator @@ -111,7 +111,7 @@ const f12 = async function * () { }; }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === const f13 = async function * () { >f13 : () => AsyncIterableIterator >async function * () { yield;} : () => AsyncIterableIterator @@ -120,7 +120,7 @@ const f13 = async function * () { >yield : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === const f14 = async function * () { >f14 : () => AsyncIterableIterator >async function * () { yield 1;} : () => AsyncIterableIterator @@ -130,7 +130,7 @@ const f14 = async function * () { >1 : 1 }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === const f15 = async function * () { >f15 : () => AsyncIterableIterator >async function * () { yield *;} : () => AsyncIterableIterator @@ -140,7 +140,7 @@ const f15 = async function * () { > : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === const f16 = async function * () { >f16 : () => AsyncIterableIterator >async function * () { yield * [];} : () => AsyncIterableIterator @@ -150,7 +150,7 @@ const f16 = async function * () { >[] : undefined[] }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === const f17 = async function * () { >f17 : () => AsyncIterableIterator >async function * () { await 1;} : () => AsyncIterableIterator @@ -160,7 +160,7 @@ const f17 = async function * () { >1 : 1 }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === const f18 = async function * () { >f18 : () => AsyncIterableIterator >async function * () { await;} : () => AsyncIterableIterator @@ -170,7 +170,7 @@ const f18 = async function * () { > : any }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} const f19 = async function * () { >f19 : () => AsyncIterableIterator @@ -180,7 +180,7 @@ const f19 = async function * () { >x : await }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} const f20 = async function * () { >f20 : () => AsyncIterableIterator @@ -190,7 +190,7 @@ const f20 = async function * () { >x : yield }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === const f21 = async function *() { >f21 : () => AsyncIterableIterator >async function *() { const x = { [yield]: 1 };} : () => AsyncIterableIterator diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.errors.txt similarity index 67% rename from tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt rename to tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.errors.txt index 4fe18485a2d..e0f8adbab15 100644 --- a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.errors.txt +++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.errors.txt @@ -1,48 +1,48 @@ -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts(2,17): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts(2,14): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts(2,17): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts(2,19): error TS2524: 'await' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts(3,14): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,15): error TS2693: 'await' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,20): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(2,22): error TS1136: Property assignment expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,18): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,24): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,26): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,18): error TS1003: Identifier expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,26): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,28): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,34): error TS1109: Expression expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,36): error TS1005: ';' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,28): error TS1005: '(' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,36): error TS1005: '=>' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS2523: 'yield' expressions cannot be used in a parameter initializer. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,15): error TS2693: 'yield' only refers to a type, but is being used as a value here. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,20): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(2,22): error TS1136: Property assignment expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. -tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts(3,16): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts(2,17): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts(2,14): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts(2,17): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts(2,19): error TS2524: 'await' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts(3,14): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,15): error TS2693: 'await' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,20): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(2,22): error TS1136: Property assignment expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,18): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,24): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts(3,26): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,18): error TS1003: Identifier expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts(3,26): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,28): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,34): error TS1109: Expression expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts(3,36): error TS1005: ';' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,28): error TS1005: '(' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts(3,36): error TS1005: '=>' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts(2,19): error TS2523: 'yield' expressions cannot be used in a parameter initializer. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,15): error TS1138: Parameter declaration expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,15): error TS2693: 'yield' only refers to a type, but is being used as a value here. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,20): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(2,22): error TS1136: Property assignment expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts(4,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts(3,16): error TS1109: Expression expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts (0 errors) ==== const o1 = { async * f() { } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts (0 errors) ==== const o2 = { async * await() { } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts (0 errors) ==== const o3 = { async * yield() { } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts (5 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts (5 errors) ==== const o4 = { async * f(await) { ~~~~~ @@ -57,7 +57,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; ~ !!! error TS1128: Declaration or statement expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts (5 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts (5 errors) ==== const o5 = { async * f(yield) { ~~~~~ @@ -72,28 +72,28 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; ~ !!! error TS1128: Declaration or statement expected. -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts (1 errors) ==== const o6 = { async * f(a = await 1) { ~~~~~~~ !!! error TS2524: 'await' expressions cannot be used in a parameter initializer. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts (1 errors) ==== const o7 = { async * f(a = yield) { ~~~~~ !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts (0 errors) ==== const o8 = { async * f() { async function * g() { } } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts (2 errors) ==== const o9 = { async * f() { function yield() { @@ -104,7 +104,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts (2 errors) ==== const o10 = { async * f() { const x = function yield() { @@ -115,7 +115,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts (3 errors) ==== const o11 = { async * f() { function await() { @@ -128,7 +128,7 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa } } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts (3 errors) ==== const o12 = { async * f() { const x = function await() { @@ -141,19 +141,19 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa }; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts (0 errors) ==== const o13 = { async * f() { yield; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts (0 errors) ==== const o14 = { async * f() { yield 1; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts (1 errors) ==== const o15 = { async * f() { yield *; @@ -161,19 +161,19 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1109: Expression expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts (0 errors) ==== const o16 = { async * f() { yield * []; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts (0 errors) ==== const o17 = { async * f() { await 1; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts (1 errors) ==== const o18 = { async * f() { await; @@ -181,27 +181,27 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa !!! error TS1109: Expression expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts (0 errors) ==== interface await {} const o19 = { async * f() { let x: await; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts (0 errors) ==== interface yield {} const o20 = { async * f() { let x: yield; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts (0 errors) ==== const o21 = { async * f() { const x = { [yield]: 1 }; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts (1 errors) ==== const o22 = { async * get x() { ~ @@ -209,16 +209,17 @@ tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingVa return 1; } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts (1 errors) ==== const o23 = { async * set x(value: number) { ~ !!! error TS1005: '(' expected. } }; -==== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts (1 errors) ==== const o24 = { async * x: 1; ~ !!! error TS1005: '(' expected. - }; \ No newline at end of file + }; + \ No newline at end of file diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.symbols b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.symbols similarity index 78% rename from tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.symbols rename to tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.symbols index df64b125c65..acc79db8e8e 100644 --- a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.symbols +++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.symbols @@ -1,4 +1,4 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts === const o1 = { >o1 : Symbol(o1, Decl(methodIsOk.ts, 0, 5)) @@ -6,7 +6,7 @@ const o1 = { >f : Symbol(f, Decl(methodIsOk.ts, 0, 12)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts === const o2 = { >o2 : Symbol(o2, Decl(awaitMethodNameIsOk.ts, 0, 5)) @@ -14,7 +14,7 @@ const o2 = { >await : Symbol(await, Decl(awaitMethodNameIsOk.ts, 0, 12)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts === const o3 = { >o3 : Symbol(o3, Decl(yieldMethodNameIsOk.ts, 0, 5)) @@ -22,7 +22,7 @@ const o3 = { >yield : Symbol(yield, Decl(yieldMethodNameIsOk.ts, 0, 12)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === const o4 = { >o4 : Symbol(o4, Decl(awaitParameterIsError.ts, 0, 5)) @@ -31,7 +31,7 @@ const o4 = { >await : Symbol(await, Decl(awaitParameterIsError.ts, 1, 14)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === const o5 = { >o5 : Symbol(o5, Decl(yieldParameterIsError.ts, 0, 5)) @@ -40,7 +40,7 @@ const o5 = { >yield : Symbol(yield, Decl(yieldParameterIsError.ts, 1, 14)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === const o6 = { >o6 : Symbol(o6, Decl(awaitInParameterInitializerIsError.ts, 0, 5)) @@ -49,7 +49,7 @@ const o6 = { >a : Symbol(a, Decl(awaitInParameterInitializerIsError.ts, 1, 14)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === const o7 = { >o7 : Symbol(o7, Decl(yieldInParameterInitializerIsError.ts, 0, 5)) @@ -58,7 +58,7 @@ const o7 = { >a : Symbol(a, Decl(yieldInParameterInitializerIsError.ts, 1, 14)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === const o8 = { >o8 : Symbol(o8, Decl(nestedAsyncGeneratorIsOk.ts, 0, 5)) @@ -70,7 +70,7 @@ const o8 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === const o9 = { >o9 : Symbol(o9, Decl(nestedFunctionDeclarationNamedYieldIsError.ts, 0, 5)) @@ -82,7 +82,7 @@ const o9 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === const o10 = { >o10 : Symbol(o10, Decl(nestedFunctionExpressionNamedYieldIsError.ts, 0, 5)) @@ -95,7 +95,7 @@ const o10 = { }; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === const o11 = { >o11 : Symbol(o11, Decl(nestedFunctionDeclarationNamedAwaitIsError.ts, 0, 5)) @@ -107,7 +107,7 @@ const o11 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === const o12 = { >o12 : Symbol(o12, Decl(nestedFunctionExpressionNamedAwaitIsError.ts, 0, 5)) @@ -120,7 +120,7 @@ const o12 = { }; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === const o13 = { >o13 : Symbol(o13, Decl(yieldIsOk.ts, 0, 5)) @@ -130,7 +130,7 @@ const o13 = { yield; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === const o14 = { >o14 : Symbol(o14, Decl(yieldWithValueIsOk.ts, 0, 5)) @@ -140,7 +140,7 @@ const o14 = { yield 1; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === const o15 = { >o15 : Symbol(o15, Decl(yieldStarMissingValueIsError.ts, 0, 5)) @@ -150,7 +150,7 @@ const o15 = { yield *; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === const o16 = { >o16 : Symbol(o16, Decl(yieldStarWithValueIsOk.ts, 0, 5)) @@ -160,7 +160,7 @@ const o16 = { yield * []; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === const o17 = { >o17 : Symbol(o17, Decl(awaitWithValueIsOk.ts, 0, 5)) @@ -170,7 +170,7 @@ const o17 = { await 1; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === const o18 = { >o18 : Symbol(o18, Decl(awaitMissingValueIsError.ts, 0, 5)) @@ -180,7 +180,7 @@ const o18 = { await; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} >await : Symbol(await, Decl(awaitAsTypeIsOk.ts, 0, 0)) @@ -195,7 +195,7 @@ const o19 = { >await : Symbol(await, Decl(awaitAsTypeIsOk.ts, 0, 0)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} >yield : Symbol(yield, Decl(yieldAsTypeIsOk.ts, 0, 0)) @@ -210,7 +210,7 @@ const o20 = { >yield : Symbol(yield, Decl(yieldAsTypeIsOk.ts, 0, 0)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === const o21 = { >o21 : Symbol(o21, Decl(yieldInNestedComputedPropertyIsOk.ts, 0, 5)) @@ -222,7 +222,7 @@ const o21 = { >[yield] : Symbol([yield], Decl(yieldInNestedComputedPropertyIsOk.ts, 2, 19)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === const o22 = { >o22 : Symbol(o22, Decl(asyncGeneratorGetAccessorIsError.ts, 0, 5)) @@ -233,7 +233,7 @@ const o22 = { return 1; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === const o23 = { >o23 : Symbol(o23, Decl(asyncGeneratorSetAccessorIsError.ts, 0, 5)) @@ -243,7 +243,7 @@ const o23 = { >value : Symbol(value, Decl(asyncGeneratorSetAccessorIsError.ts, 1, 18)) } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts === const o24 = { >o24 : Symbol(o24, Decl(asyncGeneratorPropertyIsError.ts, 0, 5)) @@ -251,3 +251,4 @@ const o24 = { >x : Symbol(x, Decl(asyncGeneratorPropertyIsError.ts, 0, 13)) }; + diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.types b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types similarity index 79% rename from tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.types rename to tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types index 4cdaa6c1813..655ecb3e6a0 100644 --- a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.types +++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/methodIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts === const o1 = { >o1 : { f(): AsyncIterableIterator; } >{ async * f() { }} : { f(): AsyncIterableIterator; } @@ -7,7 +7,7 @@ const o1 = { >f : () => AsyncIterableIterator } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts === const o2 = { >o2 : { await(): AsyncIterableIterator; } >{ async * await() { }} : { await(): AsyncIterableIterator; } @@ -16,7 +16,7 @@ const o2 = { >await : () => AsyncIterableIterator } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldMethodNameIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts === const o3 = { >o3 : { yield(): AsyncIterableIterator; } >{ async * yield() { }} : { yield(): AsyncIterableIterator; } @@ -25,7 +25,7 @@ const o3 = { >yield : () => AsyncIterableIterator } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts === const o4 = { >o4 : { f(): any; await: any; } >{ async * f(await) : { f(): any; await: any; } @@ -35,7 +35,7 @@ const o4 = { >await : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldParameterIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts === const o5 = { >o5 : { f(): any; yield: any; } >{ async * f(yield) : { f(): any; yield: any; } @@ -45,7 +45,7 @@ const o5 = { >yield : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts === const o6 = { >o6 : { f(a?: number): AsyncIterableIterator; } >{ async * f(a = await 1) { }} : { f(a?: number): AsyncIterableIterator; } @@ -57,7 +57,7 @@ const o6 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInParameterInitializerIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts === const o7 = { >o7 : { f(a?: any): AsyncIterableIterator; } >{ async * f(a = yield) { }} : { f(a?: any): AsyncIterableIterator; } @@ -68,7 +68,7 @@ const o7 = { >yield : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedAsyncGeneratorIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts === const o8 = { >o8 : { f(): AsyncIterableIterator; } >{ async * f() { async function * g() { } }} : { f(): AsyncIterableIterator; } @@ -81,7 +81,7 @@ const o8 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts === const o9 = { >o9 : { f(): AsyncIterableIterator<() => void>; } >{ async * f() { function yield() { } }} : { f(): AsyncIterableIterator<() => void>; } @@ -96,7 +96,7 @@ const o9 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts === const o10 = { >o10 : { f(): AsyncIterableIterator<() => void>; } >{ async * f() { const x = function yield() { }; }} : { f(): AsyncIterableIterator<() => void>; } @@ -113,7 +113,7 @@ const o10 = { }; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts === const o11 = { >o11 : { f(): AsyncIterableIterator; } >{ async * f() { function await() { } }} : { f(): AsyncIterableIterator; } @@ -129,7 +129,7 @@ const o11 = { } } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts === const o12 = { >o12 : { f(): AsyncIterableIterator; } >{ async * f() { const x = function await() { }; }} : { f(): AsyncIterableIterator; } @@ -147,7 +147,7 @@ const o12 = { }; } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts === const o13 = { >o13 : { f(): AsyncIterableIterator; } >{ async * f() { yield; }} : { f(): AsyncIterableIterator; } @@ -159,7 +159,7 @@ const o13 = { >yield : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts === const o14 = { >o14 : { f(): AsyncIterableIterator; } >{ async * f() { yield 1; }} : { f(): AsyncIterableIterator; } @@ -172,7 +172,7 @@ const o14 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts === const o15 = { >o15 : { f(): AsyncIterableIterator; } >{ async * f() { yield *; }} : { f(): AsyncIterableIterator; } @@ -185,7 +185,7 @@ const o15 = { > : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldStarWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts === const o16 = { >o16 : { f(): AsyncIterableIterator; } >{ async * f() { yield * []; }} : { f(): AsyncIterableIterator; } @@ -198,7 +198,7 @@ const o16 = { >[] : undefined[] } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitWithValueIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts === const o17 = { >o17 : { f(): AsyncIterableIterator; } >{ async * f() { await 1; }} : { f(): AsyncIterableIterator; } @@ -211,7 +211,7 @@ const o17 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitMissingValueIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts === const o18 = { >o18 : { f(): AsyncIterableIterator; } >{ async * f() { await; }} : { f(): AsyncIterableIterator; } @@ -224,7 +224,7 @@ const o18 = { > : any } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/awaitAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts === interface await {} const o19 = { >o19 : { f(): AsyncIterableIterator; } @@ -237,7 +237,7 @@ const o19 = { >x : await } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldAsTypeIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts === interface yield {} const o20 = { >o20 : { f(): AsyncIterableIterator; } @@ -250,7 +250,7 @@ const o20 = { >x : yield } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts === const o21 = { >o21 : { f(): AsyncIterableIterator; } >{ async * f() { const x = { [yield]: 1 }; }} : { f(): AsyncIterableIterator; } @@ -266,7 +266,7 @@ const o21 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorGetAccessorIsError.ts === const o22 = { >o22 : { get(): any; x(): number; } >{ async * get x() { return 1; }} : { get(): any; x(): number; } @@ -279,7 +279,7 @@ const o22 = { >1 : 1 } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorSetAccessorIsError.ts === const o23 = { >o23 : { set(): any; x(value: number): void; } >{ async * set x(value: number) { }} : { set(): any; x(value: number): void; } @@ -290,7 +290,7 @@ const o23 = { >value : number } }; -=== tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/asyncGeneratorPropertyIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/asyncGenerators/asyncGeneratorPropertyIsError.ts === const o24 = { >o24 : { x(): 1; } >{ async * x: 1;} : { x(): 1; } @@ -299,3 +299,4 @@ const o24 = { >x : () => 1 }; + diff --git a/tests/baselines/reference/parser.forAwait.esnext.errors.txt b/tests/baselines/reference/parser.forAwait.es2018.errors.txt similarity index 68% rename from tests/baselines/reference/parser.forAwait.esnext.errors.txt rename to tests/baselines/reference/parser.forAwait.es2018.errors.txt index 44dfd947b56..e0e848db769 100644 --- a/tests/baselines/reference/parser.forAwait.esnext.errors.txt +++ b/tests/baselines/reference/parser.forAwait.es2018.errors.txt @@ -1,27 +1,27 @@ -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts(1,20): error TS1005: 'of' expected. -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts(1,23): error TS2304: Cannot find name 'y'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts(1,12): error TS2304: Cannot find name 'x'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts(1,14): error TS1005: 'of' expected. -tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts(1,17): error TS2304: Cannot find name 'y'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithDeclIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithExprIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithDeclIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithExprIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts(1,5): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts(1,23): error TS2304: Cannot find name 'y'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts(1,5): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts(1,12): error TS2304: Cannot find name 'x'. -tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts(1,17): error TS2304: Cannot find name 'y'. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts(1,20): error TS1005: 'of' expected. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts(1,23): error TS2304: Cannot find name 'y'. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts(1,12): error TS2304: Cannot find name 'x'. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts(1,14): error TS1005: 'of' expected. +tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts(1,17): error TS2304: Cannot find name 'y'. +tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithDeclIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithExprIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithDeclIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithExprIsError.ts(3,9): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts(1,5): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts(1,23): error TS2304: Cannot find name 'y'. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts(1,5): error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts(1,12): error TS2304: Cannot find name 'x'. +tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts(1,17): error TS2304: Cannot find name 'y'. -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts (2 errors) ==== for await (const x of y) { ~~~~~ !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. ~ !!! error TS2304: Cannot find name 'y'. } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts (3 errors) ==== for await (x of y) { ~~~~~ !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. @@ -30,14 +30,14 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t ~ !!! error TS2304: Cannot find name 'y'. } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts (2 errors) ==== for await (const x in y) { ~~ !!! error TS1005: 'of' expected. ~ !!! error TS2304: Cannot find name 'y'. } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts (3 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts (3 errors) ==== for await (x in y) { ~ !!! error TS2304: Cannot find name 'x'. @@ -46,7 +46,7 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t ~ !!! error TS2304: Cannot find name 'y'. } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithDeclIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithDeclIsError.ts (1 errors) ==== function f5() { let y: any; for await (const x of y) { @@ -54,7 +54,7 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithExprIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithExprIsError.ts (1 errors) ==== function f6() { let x: any, y: any; for await (x of y) { @@ -62,31 +62,31 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithDeclIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithDeclIsOk.ts (0 errors) ==== async function f7() { let y: any; for await (const x of y) { } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithExprIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithExprIsOk.ts (0 errors) ==== async function f8() { let x: any, y: any; for await (x of y) { } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithDeclIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithDeclIsOk.ts (0 errors) ==== async function* f9() { let y: any; for await (const x of y) { } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithExpressionIsOk.ts (0 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithExpressionIsOk.ts (0 errors) ==== async function* f10() { let x: any, y: any; for await (x of y) { } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithDeclIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithDeclIsError.ts (1 errors) ==== function* f11() { let y: any; for await (const x of y) { @@ -94,11 +94,12 @@ tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.t !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. } } -==== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithExprIsError.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithExprIsError.ts (1 errors) ==== function* f12() { let x: any, y: any; for await (x of y) { ~~~~~ !!! error TS1103: A 'for-await-of' statement is only allowed within an async function or async generator. } - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/parser.forAwait.esnext.symbols b/tests/baselines/reference/parser.forAwait.es2018.symbols similarity index 80% rename from tests/baselines/reference/parser.forAwait.esnext.symbols rename to tests/baselines/reference/parser.forAwait.es2018.symbols index 226445cb79a..c859ebda943 100644 --- a/tests/baselines/reference/parser.forAwait.esnext.symbols +++ b/tests/baselines/reference/parser.forAwait.es2018.symbols @@ -1,18 +1,18 @@ -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts === for await (const x of y) { >x : Symbol(x, Decl(topLevelWithDeclIsError.ts, 0, 16)) } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts === for await (x of y) { No type information for this code.} -No type information for this code.=== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts === +No type information for this code.=== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts === for await (const x in y) { >x : Symbol(x, Decl(forAwaitInWithDeclIsError.ts, 0, 16)) } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts === for await (x in y) { No type information for this code.} -No type information for this code.=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithDeclIsError.ts === +No type information for this code.=== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithDeclIsError.ts === function f5() { >f5 : Symbol(f5, Decl(inFunctionDeclWithDeclIsError.ts, 0, 0)) @@ -24,7 +24,7 @@ function f5() { >y : Symbol(y, Decl(inFunctionDeclWithDeclIsError.ts, 1, 7)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithExprIsError.ts === function f6() { >f6 : Symbol(f6, Decl(inFunctionDeclWithExprIsError.ts, 0, 0)) @@ -37,7 +37,7 @@ function f6() { >y : Symbol(y, Decl(inFunctionDeclWithExprIsError.ts, 1, 15)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithDeclIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithDeclIsOk.ts === async function f7() { >f7 : Symbol(f7, Decl(inAsyncFunctionWithDeclIsOk.ts, 0, 0)) @@ -49,7 +49,7 @@ async function f7() { >y : Symbol(y, Decl(inAsyncFunctionWithDeclIsOk.ts, 1, 7)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithExprIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithExprIsOk.ts === async function f8() { >f8 : Symbol(f8, Decl(inAsyncFunctionWithExprIsOk.ts, 0, 0)) @@ -62,7 +62,7 @@ async function f8() { >y : Symbol(y, Decl(inAsyncFunctionWithExprIsOk.ts, 1, 15)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithDeclIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithDeclIsOk.ts === async function* f9() { >f9 : Symbol(f9, Decl(inAsyncGeneratorWithDeclIsOk.ts, 0, 0)) @@ -74,7 +74,7 @@ async function* f9() { >y : Symbol(y, Decl(inAsyncGeneratorWithDeclIsOk.ts, 1, 7)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithExpressionIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithExpressionIsOk.ts === async function* f10() { >f10 : Symbol(f10, Decl(inAsyncGeneratorWithExpressionIsOk.ts, 0, 0)) @@ -87,7 +87,7 @@ async function* f10() { >y : Symbol(y, Decl(inAsyncGeneratorWithExpressionIsOk.ts, 1, 15)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithDeclIsError.ts === function* f11() { >f11 : Symbol(f11, Decl(inGeneratorWithDeclIsError.ts, 0, 0)) @@ -99,7 +99,7 @@ function* f11() { >y : Symbol(y, Decl(inGeneratorWithDeclIsError.ts, 1, 7)) } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithExprIsError.ts === function* f12() { >f12 : Symbol(f12, Decl(inGeneratorWithExprIsError.ts, 0, 0)) @@ -112,3 +112,4 @@ function* f12() { >y : Symbol(y, Decl(inGeneratorWithExprIsError.ts, 1, 15)) } } + diff --git a/tests/baselines/reference/parser.forAwait.esnext.types b/tests/baselines/reference/parser.forAwait.es2018.types similarity index 64% rename from tests/baselines/reference/parser.forAwait.esnext.types rename to tests/baselines/reference/parser.forAwait.es2018.types index 28408aa3c14..672d063883d 100644 --- a/tests/baselines/reference/parser.forAwait.esnext.types +++ b/tests/baselines/reference/parser.forAwait.es2018.types @@ -1,24 +1,24 @@ -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithDeclIsError.ts === for await (const x of y) { >x : any >y : any } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/topLevelWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/topLevelWithExprIsError.ts === for await (x of y) { >x : any >y : any } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithDeclIsError.ts === for await (const x in y) { >x : string >y : any } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/forAwaitInWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/forAwaitInWithExprIsError.ts === for await (x in y) { >x : any >y : any } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithDeclIsError.ts === function f5() { >f5 : () => void @@ -30,7 +30,7 @@ function f5() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inFunctionDeclWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inFunctionDeclWithExprIsError.ts === function f6() { >f6 : () => void @@ -43,7 +43,7 @@ function f6() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithDeclIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithDeclIsOk.ts === async function f7() { >f7 : () => Promise @@ -55,7 +55,7 @@ async function f7() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncFunctionWithExprIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncFunctionWithExprIsOk.ts === async function f8() { >f8 : () => Promise @@ -68,7 +68,7 @@ async function f8() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithDeclIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithDeclIsOk.ts === async function* f9() { >f9 : () => AsyncIterableIterator @@ -80,7 +80,7 @@ async function* f9() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inAsyncGeneratorWithExpressionIsOk.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithExpressionIsOk.ts === async function* f10() { >f10 : () => AsyncIterableIterator @@ -93,7 +93,7 @@ async function* f10() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithDeclIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithDeclIsError.ts === function* f11() { >f11 : () => IterableIterator @@ -105,7 +105,7 @@ function* f11() { >y : any } } -=== tests/cases/conformance/parser/ecmascriptnext/forAwait/inGeneratorWithExprIsError.ts === +=== tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithExprIsError.ts === function* f12() { >f12 : () => IterableIterator @@ -118,3 +118,4 @@ function* f12() { >y : any } } + diff --git a/tests/baselines/reference/recursiveMappedTypes.errors.txt b/tests/baselines/reference/recursiveMappedTypes.errors.txt index b702cf7e316..f2f59052a90 100644 --- a/tests/baselines/reference/recursiveMappedTypes.errors.txt +++ b/tests/baselines/reference/recursiveMappedTypes.errors.txt @@ -4,9 +4,10 @@ tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(7,6): error TS2456: tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(8,11): error TS2313: Type parameter 'K' has a circular constraint. tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(11,6): error TS2456: Type alias 'Recurse2' circularly references itself. tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(12,11): error TS2313: Type parameter 'K' has a circular constraint. +tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(20,19): error TS2589: Type instantiation is excessively deep and possibly infinite. -==== tests/cases/conformance/types/mapped/recursiveMappedTypes.ts (6 errors) ==== +==== tests/cases/conformance/types/mapped/recursiveMappedTypes.ts (7 errors) ==== // Recursive mapped types simply appear empty type Recurse = { @@ -39,6 +40,47 @@ tests/cases/conformance/types/mapped/recursiveMappedTypes.ts(12,11): error TS231 type tup = [number, number, number, number]; function foo(arg: Circular): tup { + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. return arg; } + + // Repro from #29442 + + type DeepMap = { + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; + }; + + type tpl = [string, [string, [string]]]; + type arr = string[][]; + + type t1 = DeepMap; // [number, [number, [number]]] + type t2 = DeepMap; // number[][] + + // Repro from #29577 + + type Transform = { [K in keyof T]: Transform }; + + interface User { + avatar: string; + } + + interface Guest { + displayName: string; + } + + interface Product { + users: (User | Guest)[]; + } + + declare var product: Transform; + product.users; // (Transform | Transform)[] + + // Repro from #29702 + + type Remap1 = { [P in keyof T]: Remap1; }; + type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; + + type a = Remap1; // string[] + type b = Remap2; // string[] \ No newline at end of file diff --git a/tests/baselines/reference/recursiveMappedTypes.js b/tests/baselines/reference/recursiveMappedTypes.js index 612c9d3fca4..e9e44a1df41 100644 --- a/tests/baselines/reference/recursiveMappedTypes.js +++ b/tests/baselines/reference/recursiveMappedTypes.js @@ -21,6 +21,45 @@ type tup = [number, number, number, number]; function foo(arg: Circular): tup { return arg; } + +// Repro from #29442 + +type DeepMap = { + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; +}; + +type tpl = [string, [string, [string]]]; +type arr = string[][]; + +type t1 = DeepMap; // [number, [number, [number]]] +type t2 = DeepMap; // number[][] + +// Repro from #29577 + +type Transform = { [K in keyof T]: Transform }; + +interface User { + avatar: string; +} + +interface Guest { + displayName: string; +} + +interface Product { + users: (User | Guest)[]; +} + +declare var product: Transform; +product.users; // (Transform | Transform)[] + +// Repro from #29702 + +type Remap1 = { [P in keyof T]: Remap1; }; +type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; + +type a = Remap1; // string[] +type b = Remap2; // string[] //// [recursiveMappedTypes.js] @@ -30,6 +69,7 @@ exports.__esModule = true; function foo(arg) { return arg; } +product.users; // (Transform | Transform)[] //// [recursiveMappedTypes.d.ts] diff --git a/tests/baselines/reference/recursiveMappedTypes.symbols b/tests/baselines/reference/recursiveMappedTypes.symbols index 7c0e2ffaa23..1638dc03f56 100644 --- a/tests/baselines/reference/recursiveMappedTypes.symbols +++ b/tests/baselines/reference/recursiveMappedTypes.symbols @@ -55,3 +55,113 @@ function foo(arg: Circular): tup { >arg : Symbol(arg, Decl(recursiveMappedTypes.ts, 19, 13)) } +// Repro from #29442 + +type DeepMap = { +>DeepMap : Symbol(DeepMap, Decl(recursiveMappedTypes.ts, 21, 1)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 25, 13)) +>R : Symbol(R, Decl(recursiveMappedTypes.ts, 25, 33)) + + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 26, 3)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 25, 13)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 25, 13)) +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 26, 3)) +>DeepMap : Symbol(DeepMap, Decl(recursiveMappedTypes.ts, 21, 1)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 25, 13)) +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 26, 3)) +>R : Symbol(R, Decl(recursiveMappedTypes.ts, 25, 33)) +>R : Symbol(R, Decl(recursiveMappedTypes.ts, 25, 33)) + +}; + +type tpl = [string, [string, [string]]]; +>tpl : Symbol(tpl, Decl(recursiveMappedTypes.ts, 27, 2)) + +type arr = string[][]; +>arr : Symbol(arr, Decl(recursiveMappedTypes.ts, 29, 40)) + +type t1 = DeepMap; // [number, [number, [number]]] +>t1 : Symbol(t1, Decl(recursiveMappedTypes.ts, 30, 22)) +>DeepMap : Symbol(DeepMap, Decl(recursiveMappedTypes.ts, 21, 1)) +>tpl : Symbol(tpl, Decl(recursiveMappedTypes.ts, 27, 2)) + +type t2 = DeepMap; // number[][] +>t2 : Symbol(t2, Decl(recursiveMappedTypes.ts, 32, 31)) +>DeepMap : Symbol(DeepMap, Decl(recursiveMappedTypes.ts, 21, 1)) +>arr : Symbol(arr, Decl(recursiveMappedTypes.ts, 29, 40)) + +// Repro from #29577 + +type Transform = { [K in keyof T]: Transform }; +>Transform : Symbol(Transform, Decl(recursiveMappedTypes.ts, 33, 31)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 37, 15)) +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 37, 23)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 37, 15)) +>Transform : Symbol(Transform, Decl(recursiveMappedTypes.ts, 33, 31)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 37, 15)) +>K : Symbol(K, Decl(recursiveMappedTypes.ts, 37, 23)) + +interface User { +>User : Symbol(User, Decl(recursiveMappedTypes.ts, 37, 56)) + + avatar: string; +>avatar : Symbol(User.avatar, Decl(recursiveMappedTypes.ts, 39, 16)) +} + +interface Guest { +>Guest : Symbol(Guest, Decl(recursiveMappedTypes.ts, 41, 1)) + + displayName: string; +>displayName : Symbol(Guest.displayName, Decl(recursiveMappedTypes.ts, 43, 17)) +} + +interface Product { +>Product : Symbol(Product, Decl(recursiveMappedTypes.ts, 45, 1)) + + users: (User | Guest)[]; +>users : Symbol(Product.users, Decl(recursiveMappedTypes.ts, 47, 19)) +>User : Symbol(User, Decl(recursiveMappedTypes.ts, 37, 56)) +>Guest : Symbol(Guest, Decl(recursiveMappedTypes.ts, 41, 1)) +} + +declare var product: Transform; +>product : Symbol(product, Decl(recursiveMappedTypes.ts, 51, 11)) +>Transform : Symbol(Transform, Decl(recursiveMappedTypes.ts, 33, 31)) +>Product : Symbol(Product, Decl(recursiveMappedTypes.ts, 45, 1)) + +product.users; // (Transform | Transform)[] +>product.users : Symbol(users, Decl(recursiveMappedTypes.ts, 47, 19)) +>product : Symbol(product, Decl(recursiveMappedTypes.ts, 51, 11)) +>users : Symbol(users, Decl(recursiveMappedTypes.ts, 47, 19)) + +// Repro from #29702 + +type Remap1 = { [P in keyof T]: Remap1; }; +>Remap1 : Symbol(Remap1, Decl(recursiveMappedTypes.ts, 52, 14)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 56, 12)) +>P : Symbol(P, Decl(recursiveMappedTypes.ts, 56, 20)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 56, 12)) +>Remap1 : Symbol(Remap1, Decl(recursiveMappedTypes.ts, 52, 14)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 56, 12)) +>P : Symbol(P, Decl(recursiveMappedTypes.ts, 56, 20)) + +type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; +>Remap2 : Symbol(Remap2, Decl(recursiveMappedTypes.ts, 56, 51)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) +>P : Symbol(P, Decl(recursiveMappedTypes.ts, 57, 39)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) +>Remap2 : Symbol(Remap2, Decl(recursiveMappedTypes.ts, 56, 51)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) +>P : Symbol(P, Decl(recursiveMappedTypes.ts, 57, 39)) +>T : Symbol(T, Decl(recursiveMappedTypes.ts, 57, 12)) + +type a = Remap1; // string[] +>a : Symbol(a, Decl(recursiveMappedTypes.ts, 57, 74)) +>Remap1 : Symbol(Remap1, Decl(recursiveMappedTypes.ts, 52, 14)) + +type b = Remap2; // string[] +>b : Symbol(b, Decl(recursiveMappedTypes.ts, 59, 26)) +>Remap2 : Symbol(Remap2, Decl(recursiveMappedTypes.ts, 56, 51)) + diff --git a/tests/baselines/reference/recursiveMappedTypes.types b/tests/baselines/reference/recursiveMappedTypes.types index 5741f711e9d..126d1e1d740 100644 --- a/tests/baselines/reference/recursiveMappedTypes.types +++ b/tests/baselines/reference/recursiveMappedTypes.types @@ -28,10 +28,72 @@ type tup = [number, number, number, number]; >tup : [number, number, number, number] function foo(arg: Circular): tup { ->foo : (arg: [any, any, any, any]) => [number, number, number, number] ->arg : [any, any, any, any] +>foo : (arg: any) => [number, number, number, number] +>arg : any return arg; ->arg : [any, any, any, any] +>arg : any } +// Repro from #29442 + +type DeepMap = { +>DeepMap : DeepMap + + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; +}; + +type tpl = [string, [string, [string]]]; +>tpl : [string, [string, [string]]] + +type arr = string[][]; +>arr : string[][] + +type t1 = DeepMap; // [number, [number, [number]]] +>t1 : [number, [number, [number]]] + +type t2 = DeepMap; // number[][] +>t2 : number[][] + +// Repro from #29577 + +type Transform = { [K in keyof T]: Transform }; +>Transform : Transform + +interface User { + avatar: string; +>avatar : string +} + +interface Guest { + displayName: string; +>displayName : string +} + +interface Product { + users: (User | Guest)[]; +>users : (User | Guest)[] +} + +declare var product: Transform; +>product : Transform + +product.users; // (Transform | Transform)[] +>product.users : (Transform | Transform)[] +>product : Transform +>users : (Transform | Transform)[] + +// Repro from #29702 + +type Remap1 = { [P in keyof T]: Remap1; }; +>Remap1 : Remap1 + +type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; +>Remap2 : Remap2 + +type a = Remap1; // string[] +>a : string[] + +type b = Remap2; // string[] +>b : string[] + diff --git a/tests/baselines/reference/strictPropertyInitialization.errors.txt b/tests/baselines/reference/strictPropertyInitialization.errors.txt index 4a3fe0eb3e5..17283f61162 100644 --- a/tests/baselines/reference/strictPropertyInitialization.errors.txt +++ b/tests/baselines/reference/strictPropertyInitialization.errors.txt @@ -117,4 +117,15 @@ tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitial let y = this.c; } } + + // Property is considered initialized by type any even though value could be undefined + + declare function someValue(): any; + + class C11 { + a: number; + constructor() { + this.a = someValue(); + } + } \ No newline at end of file diff --git a/tests/baselines/reference/strictPropertyInitialization.js b/tests/baselines/reference/strictPropertyInitialization.js index 6de5084e40c..3593fdb37f8 100644 --- a/tests/baselines/reference/strictPropertyInitialization.js +++ b/tests/baselines/reference/strictPropertyInitialization.js @@ -97,6 +97,17 @@ class C10 { let y = this.c; } } + +// Property is considered initialized by type any even though value could be undefined + +declare function someValue(): any; + +class C11 { + a: number; + constructor() { + this.a = someValue(); + } +} //// [strictPropertyInitialization.js] @@ -172,6 +183,12 @@ var C10 = /** @class */ (function () { } return C10; }()); +var C11 = /** @class */ (function () { + function C11() { + this.a = someValue(); + } + return C11; +}()); //// [strictPropertyInitialization.d.ts] @@ -227,3 +244,8 @@ declare class C10 { c?: number; constructor(); } +declare function someValue(): any; +declare class C11 { + a: number; + constructor(); +} diff --git a/tests/baselines/reference/strictPropertyInitialization.symbols b/tests/baselines/reference/strictPropertyInitialization.symbols index c271094a527..6421d0b6920 100644 --- a/tests/baselines/reference/strictPropertyInitialization.symbols +++ b/tests/baselines/reference/strictPropertyInitialization.symbols @@ -210,3 +210,23 @@ class C10 { } } +// Property is considered initialized by type any even though value could be undefined + +declare function someValue(): any; +>someValue : Symbol(someValue, Decl(strictPropertyInitialization.ts, 97, 1)) + +class C11 { +>C11 : Symbol(C11, Decl(strictPropertyInitialization.ts, 101, 34)) + + a: number; +>a : Symbol(C11.a, Decl(strictPropertyInitialization.ts, 103, 11)) + + constructor() { + this.a = someValue(); +>this.a : Symbol(C11.a, Decl(strictPropertyInitialization.ts, 103, 11)) +>this : Symbol(C11, Decl(strictPropertyInitialization.ts, 101, 34)) +>a : Symbol(C11.a, Decl(strictPropertyInitialization.ts, 103, 11)) +>someValue : Symbol(someValue, Decl(strictPropertyInitialization.ts, 97, 1)) + } +} + diff --git a/tests/baselines/reference/strictPropertyInitialization.types b/tests/baselines/reference/strictPropertyInitialization.types index 4c0ab3e8527..f1fe49e94e8 100644 --- a/tests/baselines/reference/strictPropertyInitialization.types +++ b/tests/baselines/reference/strictPropertyInitialization.types @@ -227,3 +227,25 @@ class C10 { } } +// Property is considered initialized by type any even though value could be undefined + +declare function someValue(): any; +>someValue : () => any + +class C11 { +>C11 : C11 + + a: number; +>a : number + + constructor() { + this.a = someValue(); +>this.a = someValue() : any +>this.a : number +>this : this +>a : number +>someValue() : any +>someValue : () => any + } +} + diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.1.symbols b/tests/baselines/reference/types.asyncGenerators.es2018.1.symbols similarity index 90% rename from tests/baselines/reference/types.asyncGenerators.esnext.1.symbols rename to tests/baselines/reference/types.asyncGenerators.es2018.1.symbols index 2b98a589b0e..27b21d4810f 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.1.symbols +++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.symbols @@ -1,19 +1,19 @@ -=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts === +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts === async function * inferReturnType1() { ->inferReturnType1 : Symbol(inferReturnType1, Decl(types.asyncGenerators.esnext.1.ts, 0, 0)) +>inferReturnType1 : Symbol(inferReturnType1, Decl(types.asyncGenerators.es2018.1.ts, 0, 0)) } async function * inferReturnType2() { ->inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.esnext.1.ts, 1, 1)) +>inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.es2018.1.ts, 1, 1)) yield; } async function * inferReturnType3() { ->inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.esnext.1.ts, 4, 1)) +>inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.es2018.1.ts, 4, 1)) yield 1; } async function * inferReturnType4() { ->inferReturnType4 : Symbol(inferReturnType4, Decl(types.asyncGenerators.esnext.1.ts, 7, 1)) +>inferReturnType4 : Symbol(inferReturnType4, Decl(types.asyncGenerators.es2018.1.ts, 7, 1)) yield Promise.resolve(1); >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) @@ -21,7 +21,7 @@ async function * inferReturnType4() { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * inferReturnType5() { ->inferReturnType5 : Symbol(inferReturnType5, Decl(types.asyncGenerators.esnext.1.ts, 10, 1)) +>inferReturnType5 : Symbol(inferReturnType5, Decl(types.asyncGenerators.es2018.1.ts, 10, 1)) yield 1; yield Promise.resolve(2); @@ -30,12 +30,12 @@ async function * inferReturnType5() { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * inferReturnType6() { ->inferReturnType6 : Symbol(inferReturnType6, Decl(types.asyncGenerators.esnext.1.ts, 14, 1)) +>inferReturnType6 : Symbol(inferReturnType6, Decl(types.asyncGenerators.es2018.1.ts, 14, 1)) yield* [1, 2]; } async function * inferReturnType7() { ->inferReturnType7 : Symbol(inferReturnType7, Decl(types.asyncGenerators.esnext.1.ts, 17, 1)) +>inferReturnType7 : Symbol(inferReturnType7, Decl(types.asyncGenerators.es2018.1.ts, 17, 1)) yield* [Promise.resolve(1)]; >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) @@ -43,18 +43,18 @@ async function * inferReturnType7() { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * inferReturnType8() { ->inferReturnType8 : Symbol(inferReturnType8, Decl(types.asyncGenerators.esnext.1.ts, 20, 1)) +>inferReturnType8 : Symbol(inferReturnType8, Decl(types.asyncGenerators.es2018.1.ts, 20, 1)) yield* (async function * () { yield 1; })(); } const assignability1: () => AsyncIterableIterator = async function * () { ->assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.esnext.1.ts, 24, 5)) +>assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.es2018.1.ts, 24, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; }; const assignability2: () => AsyncIterableIterator = async function * () { ->assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.esnext.1.ts, 27, 5)) +>assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.es2018.1.ts, 27, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -64,13 +64,13 @@ const assignability2: () => AsyncIterableIterator = async function * () }; const assignability3: () => AsyncIterableIterator = async function * () { ->assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.esnext.1.ts, 30, 5)) +>assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.es2018.1.ts, 30, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; }; const assignability4: () => AsyncIterableIterator = async function * () { ->assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.esnext.1.ts, 33, 5)) +>assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.es2018.1.ts, 33, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -80,19 +80,19 @@ const assignability4: () => AsyncIterableIterator = async function * () }; const assignability5: () => AsyncIterableIterator = async function * () { ->assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.esnext.1.ts, 36, 5)) +>assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.es2018.1.ts, 36, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); }; const assignability6: () => AsyncIterable = async function * () { ->assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.esnext.1.ts, 39, 5)) +>assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.es2018.1.ts, 39, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; }; const assignability7: () => AsyncIterable = async function * () { ->assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.esnext.1.ts, 42, 5)) +>assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.es2018.1.ts, 42, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -102,13 +102,13 @@ const assignability7: () => AsyncIterable = async function * () { }; const assignability8: () => AsyncIterable = async function * () { ->assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.esnext.1.ts, 45, 5)) +>assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.es2018.1.ts, 45, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; }; const assignability9: () => AsyncIterable = async function * () { ->assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.esnext.1.ts, 48, 5)) +>assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.es2018.1.ts, 48, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -118,19 +118,19 @@ const assignability9: () => AsyncIterable = async function * () { }; const assignability10: () => AsyncIterable = async function * () { ->assignability10 : Symbol(assignability10, Decl(types.asyncGenerators.esnext.1.ts, 51, 5)) +>assignability10 : Symbol(assignability10, Decl(types.asyncGenerators.es2018.1.ts, 51, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); }; const assignability11: () => AsyncIterator = async function * () { ->assignability11 : Symbol(assignability11, Decl(types.asyncGenerators.esnext.1.ts, 54, 5)) +>assignability11 : Symbol(assignability11, Decl(types.asyncGenerators.es2018.1.ts, 54, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; }; const assignability12: () => AsyncIterator = async function * () { ->assignability12 : Symbol(assignability12, Decl(types.asyncGenerators.esnext.1.ts, 57, 5)) +>assignability12 : Symbol(assignability12, Decl(types.asyncGenerators.es2018.1.ts, 57, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -140,13 +140,13 @@ const assignability12: () => AsyncIterator = async function * () { }; const assignability13: () => AsyncIterator = async function * () { ->assignability13 : Symbol(assignability13, Decl(types.asyncGenerators.esnext.1.ts, 60, 5)) +>assignability13 : Symbol(assignability13, Decl(types.asyncGenerators.es2018.1.ts, 60, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; }; const assignability14: () => AsyncIterator = async function * () { ->assignability14 : Symbol(assignability14, Decl(types.asyncGenerators.esnext.1.ts, 63, 5)) +>assignability14 : Symbol(assignability14, Decl(types.asyncGenerators.es2018.1.ts, 63, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -156,19 +156,19 @@ const assignability14: () => AsyncIterator = async function * () { }; const assignability15: () => AsyncIterator = async function * () { ->assignability15 : Symbol(assignability15, Decl(types.asyncGenerators.esnext.1.ts, 66, 5)) +>assignability15 : Symbol(assignability15, Decl(types.asyncGenerators.es2018.1.ts, 66, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); }; async function * explicitReturnType1(): AsyncIterableIterator { ->explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.esnext.1.ts, 68, 2)) +>explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.es2018.1.ts, 68, 2)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; } async function * explicitReturnType2(): AsyncIterableIterator { ->explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.esnext.1.ts, 71, 1)) +>explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.es2018.1.ts, 71, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -177,13 +177,13 @@ async function * explicitReturnType2(): AsyncIterableIterator { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType3(): AsyncIterableIterator { ->explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.esnext.1.ts, 74, 1)) +>explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.es2018.1.ts, 74, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; } async function * explicitReturnType4(): AsyncIterableIterator { ->explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.esnext.1.ts, 77, 1)) +>explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.es2018.1.ts, 77, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -192,19 +192,19 @@ async function * explicitReturnType4(): AsyncIterableIterator { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType5(): AsyncIterableIterator { ->explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.esnext.1.ts, 80, 1)) +>explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.es2018.1.ts, 80, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); } async function * explicitReturnType6(): AsyncIterable { ->explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.esnext.1.ts, 83, 1)) +>explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.es2018.1.ts, 83, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; } async function * explicitReturnType7(): AsyncIterable { ->explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.esnext.1.ts, 86, 1)) +>explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.es2018.1.ts, 86, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -213,13 +213,13 @@ async function * explicitReturnType7(): AsyncIterable { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType8(): AsyncIterable { ->explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.esnext.1.ts, 89, 1)) +>explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.es2018.1.ts, 89, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; } async function * explicitReturnType9(): AsyncIterable { ->explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.esnext.1.ts, 92, 1)) +>explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.es2018.1.ts, 92, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -228,19 +228,19 @@ async function * explicitReturnType9(): AsyncIterable { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType10(): AsyncIterable { ->explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.esnext.1.ts, 95, 1)) +>explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.es2018.1.ts, 95, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); } async function * explicitReturnType11(): AsyncIterator { ->explicitReturnType11 : Symbol(explicitReturnType11, Decl(types.asyncGenerators.esnext.1.ts, 98, 1)) +>explicitReturnType11 : Symbol(explicitReturnType11, Decl(types.asyncGenerators.es2018.1.ts, 98, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield 1; } async function * explicitReturnType12(): AsyncIterator { ->explicitReturnType12 : Symbol(explicitReturnType12, Decl(types.asyncGenerators.esnext.1.ts, 101, 1)) +>explicitReturnType12 : Symbol(explicitReturnType12, Decl(types.asyncGenerators.es2018.1.ts, 101, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield Promise.resolve(1); @@ -249,13 +249,13 @@ async function * explicitReturnType12(): AsyncIterator { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType13(): AsyncIterator { ->explicitReturnType13 : Symbol(explicitReturnType13, Decl(types.asyncGenerators.esnext.1.ts, 104, 1)) +>explicitReturnType13 : Symbol(explicitReturnType13, Decl(types.asyncGenerators.es2018.1.ts, 104, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [1, 2]; } async function * explicitReturnType14(): AsyncIterator { ->explicitReturnType14 : Symbol(explicitReturnType14, Decl(types.asyncGenerators.esnext.1.ts, 107, 1)) +>explicitReturnType14 : Symbol(explicitReturnType14, Decl(types.asyncGenerators.es2018.1.ts, 107, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* [Promise.resolve(1)]; @@ -264,28 +264,29 @@ async function * explicitReturnType14(): AsyncIterator { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } async function * explicitReturnType15(): AsyncIterator { ->explicitReturnType15 : Symbol(explicitReturnType15, Decl(types.asyncGenerators.esnext.1.ts, 110, 1)) +>explicitReturnType15 : Symbol(explicitReturnType15, Decl(types.asyncGenerators.es2018.1.ts, 110, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield 1; })(); } async function * explicitReturnType16(): {} { ->explicitReturnType16 : Symbol(explicitReturnType16, Decl(types.asyncGenerators.esnext.1.ts, 113, 1)) +>explicitReturnType16 : Symbol(explicitReturnType16, Decl(types.asyncGenerators.es2018.1.ts, 113, 1)) yield 1; } async function * awaitedType1() { ->awaitedType1 : Symbol(awaitedType1, Decl(types.asyncGenerators.esnext.1.ts, 116, 1)) +>awaitedType1 : Symbol(awaitedType1, Decl(types.asyncGenerators.es2018.1.ts, 116, 1)) const x = await 1; ->x : Symbol(x, Decl(types.asyncGenerators.esnext.1.ts, 118, 9)) +>x : Symbol(x, Decl(types.asyncGenerators.es2018.1.ts, 118, 9)) } async function * awaitedType2() { ->awaitedType2 : Symbol(awaitedType2, Decl(types.asyncGenerators.esnext.1.ts, 119, 1)) +>awaitedType2 : Symbol(awaitedType2, Decl(types.asyncGenerators.es2018.1.ts, 119, 1)) const x = await Promise.resolve(1); ->x : Symbol(x, Decl(types.asyncGenerators.esnext.1.ts, 121, 9)) +>x : Symbol(x, Decl(types.asyncGenerators.es2018.1.ts, 121, 9)) >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) >Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } + diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.1.types b/tests/baselines/reference/types.asyncGenerators.es2018.1.types similarity index 96% rename from tests/baselines/reference/types.asyncGenerators.esnext.1.types rename to tests/baselines/reference/types.asyncGenerators.es2018.1.types index c509e12b2fe..0f3b7753313 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.1.types +++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts === +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts === async function * inferReturnType1() { >inferReturnType1 : () => AsyncIterableIterator } @@ -430,3 +430,4 @@ async function * awaitedType2() { >resolve : { (value: T | PromiseLike): Promise; (): Promise; } >1 : 1 } + diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.2.errors.txt b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt similarity index 88% rename from tests/baselines/reference/types.asyncGenerators.esnext.2.errors.txt rename to tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt index 5e9124d9433..471cf39bed2 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.2.errors.txt +++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt @@ -1,13 +1,13 @@ -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(2,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(8,12): error TS2504: Type 'Promise' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(10,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(2,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(8,12): error TS2504: Type 'Promise' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(10,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterableIterator'. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(13,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterableIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(16,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(16,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterableIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterableIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(19,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(19,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterable'. Types of property '[Symbol.asyncIterator]' are incompatible. Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. @@ -17,35 +17,35 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts( Type 'Promise>' is not assignable to type 'Promise>'. Type 'IteratorResult' is not assignable to type 'IteratorResult'. Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(22,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(22,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterable'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(25,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(25,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterable'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterable'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(28,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(28,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(31,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(31,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(34,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(34,7): error TS2322: Type '() => AsyncIterableIterator' is not assignable to type '() => AsyncIterator'. Type 'AsyncIterableIterator' is not assignable to type 'AsyncIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(38,11): error TS2322: Type '"a"' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(41,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(44,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(47,11): error TS2322: Type '"a"' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(50,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(53,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(56,11): error TS2322: Type '"a"' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(59,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(62,12): error TS2322: Type 'string' is not assignable to type 'number'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(64,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator' but required in type 'IterableIterator'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(67,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator' but required in type 'Iterable'. -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(70,42): error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'Iterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(38,11): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(41,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(44,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(47,11): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(50,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(53,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(56,11): error TS2322: Type '"a"' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(59,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(62,12): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(64,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator' but required in type 'IterableIterator'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(67,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator' but required in type 'Iterable'. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(70,42): error TS2322: Type 'AsyncIterableIterator' is not assignable to type 'Iterator'. Types of property 'next' are incompatible. Type '(value?: any) => Promise>' is not assignable to type '(value?: any) => IteratorResult'. Type 'Promise>' is missing the following properties from type 'IteratorResult': done, value -tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts(74,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -==== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts (24 errors) ==== +==== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts (24 errors) ==== async function * inferReturnType1() { yield* {}; ~~ @@ -191,4 +191,5 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts( yield* {}; ~~ !!! error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.2.symbols b/tests/baselines/reference/types.asyncGenerators.es2018.2.symbols similarity index 86% rename from tests/baselines/reference/types.asyncGenerators.esnext.2.symbols rename to tests/baselines/reference/types.asyncGenerators.es2018.2.symbols index 2305609b9de..704aefcb42c 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.2.symbols +++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.symbols @@ -1,17 +1,17 @@ -=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts === +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts === async function * inferReturnType1() { ->inferReturnType1 : Symbol(inferReturnType1, Decl(types.asyncGenerators.esnext.2.ts, 0, 0)) +>inferReturnType1 : Symbol(inferReturnType1, Decl(types.asyncGenerators.es2018.2.ts, 0, 0)) yield* {}; } async function * inferReturnType2() { ->inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.esnext.2.ts, 2, 1)) +>inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.es2018.2.ts, 2, 1)) yield* inferReturnType2(); ->inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.esnext.2.ts, 2, 1)) +>inferReturnType2 : Symbol(inferReturnType2, Decl(types.asyncGenerators.es2018.2.ts, 2, 1)) } async function * inferReturnType3() { ->inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.esnext.2.ts, 5, 1)) +>inferReturnType3 : Symbol(inferReturnType3, Decl(types.asyncGenerators.es2018.2.ts, 5, 1)) yield* Promise.resolve([1, 2]); >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) @@ -19,133 +19,134 @@ async function * inferReturnType3() { >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) } const assignability1: () => AsyncIterableIterator = async function * () { ->assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.esnext.2.ts, 9, 5)) +>assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.es2018.2.ts, 9, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; }; const assignability2: () => AsyncIterableIterator = async function * () { ->assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.esnext.2.ts, 12, 5)) +>assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.es2018.2.ts, 12, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; }; const assignability3: () => AsyncIterableIterator = async function * () { ->assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.esnext.2.ts, 15, 5)) +>assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.es2018.2.ts, 15, 5)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); }; const assignability4: () => AsyncIterable = async function * () { ->assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.esnext.2.ts, 18, 5)) +>assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.es2018.2.ts, 18, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; }; const assignability5: () => AsyncIterable = async function * () { ->assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.esnext.2.ts, 21, 5)) +>assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.es2018.2.ts, 21, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; }; const assignability6: () => AsyncIterable = async function * () { ->assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.esnext.2.ts, 24, 5)) +>assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.es2018.2.ts, 24, 5)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); }; const assignability7: () => AsyncIterator = async function * () { ->assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.esnext.2.ts, 27, 5)) +>assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.es2018.2.ts, 27, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; }; const assignability8: () => AsyncIterator = async function * () { ->assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.esnext.2.ts, 30, 5)) +>assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.es2018.2.ts, 30, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; }; const assignability9: () => AsyncIterator = async function * () { ->assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.esnext.2.ts, 33, 5)) +>assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.es2018.2.ts, 33, 5)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); }; async function * explicitReturnType1(): AsyncIterableIterator { ->explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.esnext.2.ts, 35, 2)) +>explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.es2018.2.ts, 35, 2)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; } async function * explicitReturnType2(): AsyncIterableIterator { ->explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.esnext.2.ts, 38, 1)) +>explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.es2018.2.ts, 38, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; } async function * explicitReturnType3(): AsyncIterableIterator { ->explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.esnext.2.ts, 41, 1)) +>explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.es2018.2.ts, 41, 1)) >AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); } async function * explicitReturnType4(): AsyncIterable { ->explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.esnext.2.ts, 44, 1)) +>explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.es2018.2.ts, 44, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; } async function * explicitReturnType5(): AsyncIterable { ->explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.esnext.2.ts, 47, 1)) +>explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.es2018.2.ts, 47, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; } async function * explicitReturnType6(): AsyncIterable { ->explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.esnext.2.ts, 50, 1)) +>explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.es2018.2.ts, 50, 1)) >AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); } async function * explicitReturnType7(): AsyncIterator { ->explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.esnext.2.ts, 53, 1)) +>explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.es2018.2.ts, 53, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield "a"; } async function * explicitReturnType8(): AsyncIterator { ->explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.esnext.2.ts, 56, 1)) +>explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.es2018.2.ts, 56, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* ["a", "b"]; } async function * explicitReturnType9(): AsyncIterator { ->explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.esnext.2.ts, 59, 1)) +>explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.es2018.2.ts, 59, 1)) >AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --)) yield* (async function * () { yield "a"; })(); } async function * explicitReturnType10(): IterableIterator { ->explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.esnext.2.ts, 62, 1)) +>explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.es2018.2.ts, 62, 1)) >IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --)) yield 1; } async function * explicitReturnType11(): Iterable { ->explicitReturnType11 : Symbol(explicitReturnType11, Decl(types.asyncGenerators.esnext.2.ts, 65, 1)) +>explicitReturnType11 : Symbol(explicitReturnType11, Decl(types.asyncGenerators.es2018.2.ts, 65, 1)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) yield 1; } async function * explicitReturnType12(): Iterator { ->explicitReturnType12 : Symbol(explicitReturnType12, Decl(types.asyncGenerators.esnext.2.ts, 68, 1)) +>explicitReturnType12 : Symbol(explicitReturnType12, Decl(types.asyncGenerators.es2018.2.ts, 68, 1)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --)) yield 1; } async function * yieldStar() { ->yieldStar : Symbol(yieldStar, Decl(types.asyncGenerators.esnext.2.ts, 71, 1)) +>yieldStar : Symbol(yieldStar, Decl(types.asyncGenerators.es2018.2.ts, 71, 1)) yield* {}; } + diff --git a/tests/baselines/reference/types.asyncGenerators.esnext.2.types b/tests/baselines/reference/types.asyncGenerators.es2018.2.types similarity index 96% rename from tests/baselines/reference/types.asyncGenerators.esnext.2.types rename to tests/baselines/reference/types.asyncGenerators.es2018.2.types index 35474631c0a..6bcc95297a9 100644 --- a/tests/baselines/reference/types.asyncGenerators.esnext.2.types +++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts === +=== tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts === async function * inferReturnType1() { >inferReturnType1 : () => AsyncIterableIterator @@ -235,3 +235,4 @@ async function * yieldStar() { >yield* {} : any >{} : {} } + diff --git a/tests/baselines/reference/types.forAwait.es2018.1.symbols b/tests/baselines/reference/types.forAwait.es2018.1.symbols new file mode 100644 index 00000000000..a84297ae62a --- /dev/null +++ b/tests/baselines/reference/types.forAwait.es2018.1.symbols @@ -0,0 +1,77 @@ +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts === +declare const asyncIterable: AsyncIterable; +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + +declare const iterable: Iterable; +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +declare const iterableOfPromise: Iterable>; +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) + +async function f1() { +>f1 : Symbol(f1, Decl(types.forAwait.es2018.1.ts, 2, 59)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 4, 7)) + + for await (const x of asyncIterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 5, 20)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) + } + for await (const x of iterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 7, 20)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) + } + for await (const x of iterableOfPromise) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 9, 20)) +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) + } + for await (y of asyncIterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 4, 7)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) + } + for await (y of iterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 4, 7)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) + } + for await (y of iterableOfPromise) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 4, 7)) +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) + } +} +async function * f2() { +>f2 : Symbol(f2, Decl(types.forAwait.es2018.1.ts, 17, 1)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 19, 7)) + + for await (const x of asyncIterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 20, 20)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) + } + for await (const x of iterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 22, 20)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) + } + for await (const x of iterableOfPromise) { +>x : Symbol(x, Decl(types.forAwait.es2018.1.ts, 24, 20)) +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) + } + for await (y of asyncIterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 19, 7)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13)) + } + for await (y of iterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 19, 7)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13)) + } + for await (y of iterableOfPromise) { +>y : Symbol(y, Decl(types.forAwait.es2018.1.ts, 19, 7)) +>iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.es2018.1.ts, 2, 13)) + } +} + diff --git a/tests/baselines/reference/types.forAwait.esnext.1.types b/tests/baselines/reference/types.forAwait.es2018.1.types similarity index 92% rename from tests/baselines/reference/types.forAwait.esnext.1.types rename to tests/baselines/reference/types.forAwait.es2018.1.types index 69403b40593..aa1035b87cb 100644 --- a/tests/baselines/reference/types.forAwait.esnext.1.types +++ b/tests/baselines/reference/types.forAwait.es2018.1.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts === +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts === declare const asyncIterable: AsyncIterable; >asyncIterable : AsyncIterable @@ -70,3 +70,4 @@ async function * f2() { >iterableOfPromise : Iterable> } } + diff --git a/tests/baselines/reference/types.forAwait.esnext.2.errors.txt b/tests/baselines/reference/types.forAwait.es2018.2.errors.txt similarity index 77% rename from tests/baselines/reference/types.forAwait.esnext.2.errors.txt rename to tests/baselines/reference/types.forAwait.es2018.2.errors.txt index 530743d9825..cc24920d85d 100644 --- a/tests/baselines/reference/types.forAwait.esnext.2.errors.txt +++ b/tests/baselines/reference/types.forAwait.es2018.2.errors.txt @@ -1,12 +1,12 @@ -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(6,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(8,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(10,16): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(12,16): error TS2322: Type 'number' is not assignable to type 'string'. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(14,21): error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(16,15): error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(6,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(8,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(10,16): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(12,16): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(14,21): error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts(16,15): error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. -==== tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts (6 errors) ==== +==== tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts (6 errors) ==== declare const asyncIterable: AsyncIterable; declare const iterable: Iterable; async function f() { @@ -36,4 +36,5 @@ tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts(16,15): error ~~~~~~~~~~~~~ !!! error TS2488: Type 'AsyncIterable' must have a '[Symbol.iterator]()' method that returns an iterator. } - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/types.forAwait.es2018.2.symbols b/tests/baselines/reference/types.forAwait.es2018.2.symbols new file mode 100644 index 00000000000..2fb30f55ca8 --- /dev/null +++ b/tests/baselines/reference/types.forAwait.es2018.2.symbols @@ -0,0 +1,42 @@ +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts === +declare const asyncIterable: AsyncIterable; +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.2.ts, 0, 13)) +>AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) + +declare const iterable: Iterable; +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.2.ts, 1, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +async function f() { +>f : Symbol(f, Decl(types.forAwait.es2018.2.ts, 1, 41)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.2.ts, 3, 7)) + + let z: string; +>z : Symbol(z, Decl(types.forAwait.es2018.2.ts, 4, 7)) + + for await (const x of {}) { +>x : Symbol(x, Decl(types.forAwait.es2018.2.ts, 5, 20)) + } + for await (y of {}) { +>y : Symbol(y, Decl(types.forAwait.es2018.2.ts, 3, 7)) + } + for await (z of asyncIterable) { +>z : Symbol(z, Decl(types.forAwait.es2018.2.ts, 4, 7)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.2.ts, 0, 13)) + } + for await (z of iterable) { +>z : Symbol(z, Decl(types.forAwait.es2018.2.ts, 4, 7)) +>iterable : Symbol(iterable, Decl(types.forAwait.es2018.2.ts, 1, 13)) + } + for (const x of asyncIterable) { +>x : Symbol(x, Decl(types.forAwait.es2018.2.ts, 13, 14)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.2.ts, 0, 13)) + } + for (y of asyncIterable) { +>y : Symbol(y, Decl(types.forAwait.es2018.2.ts, 3, 7)) +>asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.2.ts, 0, 13)) + } +} + diff --git a/tests/baselines/reference/types.forAwait.esnext.2.types b/tests/baselines/reference/types.forAwait.es2018.2.types similarity index 87% rename from tests/baselines/reference/types.forAwait.esnext.2.types rename to tests/baselines/reference/types.forAwait.es2018.2.types index 0c2dc0cd695..e4db7426bc0 100644 --- a/tests/baselines/reference/types.forAwait.esnext.2.types +++ b/tests/baselines/reference/types.forAwait.es2018.2.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts === +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts === declare const asyncIterable: AsyncIterable; >asyncIterable : AsyncIterable @@ -39,3 +39,4 @@ async function f() { >asyncIterable : AsyncIterable } } + diff --git a/tests/baselines/reference/types.forAwait.esnext.3.errors.txt b/tests/baselines/reference/types.forAwait.es2018.3.errors.txt similarity index 78% rename from tests/baselines/reference/types.forAwait.esnext.3.errors.txt rename to tests/baselines/reference/types.forAwait.es2018.3.errors.txt index baf8c76b24a..296ac0d066b 100644 --- a/tests/baselines/reference/types.forAwait.esnext.3.errors.txt +++ b/tests/baselines/reference/types.forAwait.es2018.3.errors.txt @@ -1,12 +1,12 @@ error TS2318: Cannot find global type 'AsyncIterableIterator'. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(3,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(5,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(10,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. -tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(12,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(3,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(5,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(10,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. +tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(12,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. !!! error TS2318: Cannot find global type 'AsyncIterableIterator'. -==== tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts (4 errors) ==== +==== tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts (4 errors) ==== async function f1() { let y: number; for await (const x of {}) { @@ -28,4 +28,5 @@ tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts(12,21): error ~~ !!! error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator. } - } \ No newline at end of file + } + \ No newline at end of file diff --git a/tests/baselines/reference/types.forAwait.es2018.3.symbols b/tests/baselines/reference/types.forAwait.es2018.3.symbols new file mode 100644 index 00000000000..b40783f9b78 --- /dev/null +++ b/tests/baselines/reference/types.forAwait.es2018.3.symbols @@ -0,0 +1,28 @@ +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts === +async function f1() { +>f1 : Symbol(f1, Decl(types.forAwait.es2018.3.ts, 0, 0)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.3.ts, 1, 7)) + + for await (const x of {}) { +>x : Symbol(x, Decl(types.forAwait.es2018.3.ts, 2, 20)) + } + for await (y of {}) { +>y : Symbol(y, Decl(types.forAwait.es2018.3.ts, 1, 7)) + } +} +async function* f2() { +>f2 : Symbol(f2, Decl(types.forAwait.es2018.3.ts, 6, 1)) + + let y: number; +>y : Symbol(y, Decl(types.forAwait.es2018.3.ts, 8, 7)) + + for await (const x of {}) { +>x : Symbol(x, Decl(types.forAwait.es2018.3.ts, 9, 20)) + } + for await (y of {}) { +>y : Symbol(y, Decl(types.forAwait.es2018.3.ts, 8, 7)) + } +} + diff --git a/tests/baselines/reference/types.forAwait.esnext.3.types b/tests/baselines/reference/types.forAwait.es2018.3.types similarity index 79% rename from tests/baselines/reference/types.forAwait.esnext.3.types rename to tests/baselines/reference/types.forAwait.es2018.3.types index 6b9ebdc4ac9..604ecadc54d 100644 --- a/tests/baselines/reference/types.forAwait.esnext.3.types +++ b/tests/baselines/reference/types.forAwait.es2018.3.types @@ -1,4 +1,4 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts === +=== tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts === async function f1() { >f1 : () => Promise @@ -29,3 +29,4 @@ async function* f2() { >{} : {} } } + diff --git a/tests/baselines/reference/types.forAwait.esnext.1.symbols b/tests/baselines/reference/types.forAwait.esnext.1.symbols deleted file mode 100644 index c3c10c42109..00000000000 --- a/tests/baselines/reference/types.forAwait.esnext.1.symbols +++ /dev/null @@ -1,76 +0,0 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts === -declare const asyncIterable: AsyncIterable; ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) ->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) - -declare const iterable: Iterable; ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -declare const iterableOfPromise: Iterable>; ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) - -async function f1() { ->f1 : Symbol(f1, Decl(types.forAwait.esnext.1.ts, 2, 59)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 4, 7)) - - for await (const x of asyncIterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 5, 20)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) - } - for await (const x of iterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 7, 20)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) - } - for await (const x of iterableOfPromise) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 9, 20)) ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) - } - for await (y of asyncIterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 4, 7)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) - } - for await (y of iterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 4, 7)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) - } - for await (y of iterableOfPromise) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 4, 7)) ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) - } -} -async function * f2() { ->f2 : Symbol(f2, Decl(types.forAwait.esnext.1.ts, 17, 1)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 19, 7)) - - for await (const x of asyncIterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 20, 20)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) - } - for await (const x of iterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 22, 20)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) - } - for await (const x of iterableOfPromise) { ->x : Symbol(x, Decl(types.forAwait.esnext.1.ts, 24, 20)) ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) - } - for await (y of asyncIterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 19, 7)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.1.ts, 0, 13)) - } - for await (y of iterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 19, 7)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.1.ts, 1, 13)) - } - for await (y of iterableOfPromise) { ->y : Symbol(y, Decl(types.forAwait.esnext.1.ts, 19, 7)) ->iterableOfPromise : Symbol(iterableOfPromise, Decl(types.forAwait.esnext.1.ts, 2, 13)) - } -} diff --git a/tests/baselines/reference/types.forAwait.esnext.2.symbols b/tests/baselines/reference/types.forAwait.esnext.2.symbols deleted file mode 100644 index 5013f1c964d..00000000000 --- a/tests/baselines/reference/types.forAwait.esnext.2.symbols +++ /dev/null @@ -1,41 +0,0 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts === -declare const asyncIterable: AsyncIterable; ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.2.ts, 0, 13)) ->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --)) - -declare const iterable: Iterable; ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.2.ts, 1, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -async function f() { ->f : Symbol(f, Decl(types.forAwait.esnext.2.ts, 1, 41)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.2.ts, 3, 7)) - - let z: string; ->z : Symbol(z, Decl(types.forAwait.esnext.2.ts, 4, 7)) - - for await (const x of {}) { ->x : Symbol(x, Decl(types.forAwait.esnext.2.ts, 5, 20)) - } - for await (y of {}) { ->y : Symbol(y, Decl(types.forAwait.esnext.2.ts, 3, 7)) - } - for await (z of asyncIterable) { ->z : Symbol(z, Decl(types.forAwait.esnext.2.ts, 4, 7)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.2.ts, 0, 13)) - } - for await (z of iterable) { ->z : Symbol(z, Decl(types.forAwait.esnext.2.ts, 4, 7)) ->iterable : Symbol(iterable, Decl(types.forAwait.esnext.2.ts, 1, 13)) - } - for (const x of asyncIterable) { ->x : Symbol(x, Decl(types.forAwait.esnext.2.ts, 13, 14)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.2.ts, 0, 13)) - } - for (y of asyncIterable) { ->y : Symbol(y, Decl(types.forAwait.esnext.2.ts, 3, 7)) ->asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.esnext.2.ts, 0, 13)) - } -} diff --git a/tests/baselines/reference/types.forAwait.esnext.3.symbols b/tests/baselines/reference/types.forAwait.esnext.3.symbols deleted file mode 100644 index c7df2f71ede..00000000000 --- a/tests/baselines/reference/types.forAwait.esnext.3.symbols +++ /dev/null @@ -1,27 +0,0 @@ -=== tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts === -async function f1() { ->f1 : Symbol(f1, Decl(types.forAwait.esnext.3.ts, 0, 0)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.3.ts, 1, 7)) - - for await (const x of {}) { ->x : Symbol(x, Decl(types.forAwait.esnext.3.ts, 2, 20)) - } - for await (y of {}) { ->y : Symbol(y, Decl(types.forAwait.esnext.3.ts, 1, 7)) - } -} -async function* f2() { ->f2 : Symbol(f2, Decl(types.forAwait.esnext.3.ts, 6, 1)) - - let y: number; ->y : Symbol(y, Decl(types.forAwait.esnext.3.ts, 8, 7)) - - for await (const x of {}) { ->x : Symbol(x, Decl(types.forAwait.esnext.3.ts, 9, 20)) - } - for await (y of {}) { ->y : Symbol(y, Decl(types.forAwait.esnext.3.ts, 8, 7)) - } -} diff --git a/tests/baselines/reference/unknownType2.errors.txt b/tests/baselines/reference/unknownType2.errors.txt new file mode 100644 index 00000000000..5f08804b9e0 --- /dev/null +++ b/tests/baselines/reference/unknownType2.errors.txt @@ -0,0 +1,231 @@ +tests/cases/conformance/types/unknown/unknownType2.ts(216,13): error TS2322: Type '"yes" | "no" | "maybe"' is not assignable to type 'SomeResponse'. + Type '"maybe"' is not assignable to type 'SomeResponse'. + + +==== tests/cases/conformance/types/unknown/unknownType2.ts (1 errors) ==== + type isUnknown = unknown extends T ? true : false; + type isTrue = T; + + type SomeResponse = 'yes' | 'no' | 'idk'; + let validate: (x: unknown) => SomeResponse = x => (x === 'yes' || x === 'no') ? x : 'idk'; // No error + + const u: unknown = undefined; + + declare const symb: unique symbol; + declare const symbNonUnique: symbol; + + if (u === 5) { + const y = u.toString(10); + } + + if (u === true || u === false) { + const someBool: boolean = u; + } + + if (u === undefined) { + const undef: undefined = u; + } + + if (u === null) { + const someNull: null = u; + } + + if (u === symb) { + const symbolAlias: typeof symb = u; + } + + if (!(u === 42)) { + type A = isTrue> + } + + if (u !== 42) { + type B = isTrue> + } + + if (u == 42) { + type C = isTrue> + } + + if (u == true) { + type D = isTrue> + } + + if (u == Object) { + type E = isTrue> + } + + declare const aString: string; + declare const aBoolean: boolean; + declare const aNumber: number; + declare const anObject: object; + declare const anObjectLiteral: { x: number }; + declare const aUnion: { x: number } | { y: string }; + declare const anIntersection: { x: number } & { y: string }; + declare const aFunction: () => number; + + if (u === aString) { + let uString: string = u; + } + + if (u === aBoolean) { + let uString: boolean = u; + } + + if (u === aNumber) { + let uNumber: number = u; + } + + if (u === anObject) { + let uObject: object = u; + } + + if (u === anObjectLiteral) { + let uObjectLiteral: object = u; + } + + if (u === aUnion) { + type unionDoesNotNarrow = isTrue> + } + + if (u === anIntersection) { + type intersectionDoesNotNarrow = isTrue> + } + + if (u === aFunction) { + let uFunction: object = u; + } + + enum NumberEnum { + A, + B, + C + } + + enum StringEnum { + A = "A", + B = "B", + C = "C" + } + + if (u === NumberEnum || u === StringEnum) { + let enumObj: object = u; + } + + if (u === NumberEnum.A) { + let a: NumberEnum.A = u + } + + if (u === StringEnum.B) { + let b: StringEnum.B = u + } + + function switchTestEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + break; + case StringEnum.B: + const b: StringEnum.B = x; + break; + case StringEnum.C: + const c: StringEnum.C = x; + break; + } + type End = isTrue> + } + + function switchTestCollectEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + case StringEnum.B: + const b: StringEnum.A | StringEnum.B = x; + case StringEnum.C: + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; + const all: StringEnum = x; + return; + } + type End = isTrue> + } + + function switchTestLiterals(x: unknown) { + switch (x) { + case 1: + const one: 1 = x; + break; + case 2: + const two: 2 = x; + break; + case 3: + const three: 3 = x; + break; + case true: + const t: true = x; + break; + case false: + const f: false = x; + break; + case "A": + const a: "A" = x; + break; + case undefined: + const undef: undefined = x; + break; + case null: + const llun: null = x; + break; + case symb: + const anotherSymbol: typeof symb = x; + break; + case symbNonUnique: + const nonUniqueSymbol: symbol = x; + break; + } + type End = isTrue> + } + + function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { + switch (x) { + case true: + case false: + const bool: boolean = x; + break; + case y: + const obj1: object = x; + break; + case z: + const obj2: object = x; + break; + } + type End = isTrue> + } + + function switchResponse(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'idk': + return x; + default: + throw new Error('unknown response'); + } + // Arguably this should be never. + type End = isTrue> + } + + function switchResponseWrong(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'maybe': + return x; // error + ~~~~~~~~~ +!!! error TS2322: Type '"yes" | "no" | "maybe"' is not assignable to type 'SomeResponse'. +!!! error TS2322: Type '"maybe"' is not assignable to type 'SomeResponse'. + default: + throw new Error('Can you repeat the question?'); + } + // Arguably this should be never. + type End = isTrue> + } + \ No newline at end of file diff --git a/tests/baselines/reference/unknownType2.js b/tests/baselines/reference/unknownType2.js index 66b763efb58..2ec5b3ed205 100644 --- a/tests/baselines/reference/unknownType2.js +++ b/tests/baselines/reference/unknownType2.js @@ -8,6 +8,7 @@ let validate: (x: unknown) => SomeResponse = x => (x === 'yes' || x === 'no') ? const u: unknown = undefined; declare const symb: unique symbol; +declare const symbNonUnique: symbol; if (u === 5) { const y = u.toString(10); @@ -106,13 +107,120 @@ if (u === NumberEnum || u === StringEnum) { let enumObj: object = u; } -if(u === NumberEnum.A) { +if (u === NumberEnum.A) { let a: NumberEnum.A = u } -if(u === StringEnum.B) { +if (u === StringEnum.B) { let b: StringEnum.B = u } + +function switchTestEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + break; + case StringEnum.B: + const b: StringEnum.B = x; + break; + case StringEnum.C: + const c: StringEnum.C = x; + break; + } + type End = isTrue> +} + +function switchTestCollectEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + case StringEnum.B: + const b: StringEnum.A | StringEnum.B = x; + case StringEnum.C: + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; + const all: StringEnum = x; + return; + } + type End = isTrue> +} + +function switchTestLiterals(x: unknown) { + switch (x) { + case 1: + const one: 1 = x; + break; + case 2: + const two: 2 = x; + break; + case 3: + const three: 3 = x; + break; + case true: + const t: true = x; + break; + case false: + const f: false = x; + break; + case "A": + const a: "A" = x; + break; + case undefined: + const undef: undefined = x; + break; + case null: + const llun: null = x; + break; + case symb: + const anotherSymbol: typeof symb = x; + break; + case symbNonUnique: + const nonUniqueSymbol: symbol = x; + break; + } + type End = isTrue> +} + +function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { + switch (x) { + case true: + case false: + const bool: boolean = x; + break; + case y: + const obj1: object = x; + break; + case z: + const obj2: object = x; + break; + } + type End = isTrue> +} + +function switchResponse(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'idk': + return x; + default: + throw new Error('unknown response'); + } + // Arguably this should be never. + type End = isTrue> +} + +function switchResponseWrong(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'maybe': + return x; // error + default: + throw new Error('Can you repeat the question?'); + } + // Arguably this should be never. + type End = isTrue> +} //// [unknownType2.js] @@ -187,3 +295,96 @@ if (u === NumberEnum.A) { if (u === StringEnum.B) { var b = u; } +function switchTestEnum(x) { + switch (x) { + case StringEnum.A: + var a = x; + break; + case StringEnum.B: + var b = x; + break; + case StringEnum.C: + var c = x; + break; + } +} +function switchTestCollectEnum(x) { + switch (x) { + case StringEnum.A: + var a = x; + case StringEnum.B: + var b = x; + case StringEnum.C: + var c = x; + var all = x; + return; + } +} +function switchTestLiterals(x) { + switch (x) { + case 1: + var one = x; + break; + case 2: + var two = x; + break; + case 3: + var three = x; + break; + case true: + var t = x; + break; + case false: + var f = x; + break; + case "A": + var a = x; + break; + case undefined: + var undef = x; + break; + case null: + var llun = x; + break; + case symb: + var anotherSymbol = x; + break; + case symbNonUnique: + var nonUniqueSymbol = x; + break; + } +} +function switchTestObjects(x, y, z) { + switch (x) { + case true: + case false: + var bool = x; + break; + case y: + var obj1 = x; + break; + case z: + var obj2 = x; + break; + } +} +function switchResponse(x) { + switch (x) { + case 'yes': + case 'no': + case 'idk': + return x; + default: + throw new Error('unknown response'); + } +} +function switchResponseWrong(x) { + switch (x) { + case 'yes': + case 'no': + case 'maybe': + return x; // error + default: + throw new Error('Can you repeat the question?'); + } +} diff --git a/tests/baselines/reference/unknownType2.symbols b/tests/baselines/reference/unknownType2.symbols index 577b1186def..6e871bd4de4 100644 --- a/tests/baselines/reference/unknownType2.symbols +++ b/tests/baselines/reference/unknownType2.symbols @@ -28,11 +28,14 @@ const u: unknown = undefined; declare const symb: unique symbol; >symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) +declare const symbNonUnique: symbol; +>symbNonUnique : Symbol(symbNonUnique, Decl(unknownType2.ts, 9, 13)) + if (u === 5) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) const y = u.toString(10); ->y : Symbol(y, Decl(unknownType2.ts, 11, 9)) +>y : Symbol(y, Decl(unknownType2.ts, 12, 9)) >u.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) >toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) @@ -43,7 +46,7 @@ if (u === true || u === false) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) const someBool: boolean = u; ->someBool : Symbol(someBool, Decl(unknownType2.ts, 15, 9)) +>someBool : Symbol(someBool, Decl(unknownType2.ts, 16, 9)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } @@ -52,7 +55,7 @@ if (u === undefined) { >undefined : Symbol(undefined) const undef: undefined = u; ->undef : Symbol(undef, Decl(unknownType2.ts, 19, 9)) +>undef : Symbol(undef, Decl(unknownType2.ts, 20, 9)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } @@ -60,7 +63,7 @@ if (u === null) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) const someNull: null = u; ->someNull : Symbol(someNull, Decl(unknownType2.ts, 23, 9)) +>someNull : Symbol(someNull, Decl(unknownType2.ts, 24, 9)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } @@ -69,7 +72,7 @@ if (u === symb) { >symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) const symbolAlias: typeof symb = u; ->symbolAlias : Symbol(symbolAlias, Decl(unknownType2.ts, 27, 9)) +>symbolAlias : Symbol(symbolAlias, Decl(unknownType2.ts, 28, 9)) >symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } @@ -78,7 +81,7 @@ if (!(u === 42)) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) type A = isTrue> ->A : Symbol(A, Decl(unknownType2.ts, 30, 18)) +>A : Symbol(A, Decl(unknownType2.ts, 31, 18)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -88,7 +91,7 @@ if (u !== 42) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) type B = isTrue> ->B : Symbol(B, Decl(unknownType2.ts, 34, 15)) +>B : Symbol(B, Decl(unknownType2.ts, 35, 15)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -98,7 +101,7 @@ if (u == 42) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) type C = isTrue> ->C : Symbol(C, Decl(unknownType2.ts, 38, 14)) +>C : Symbol(C, Decl(unknownType2.ts, 39, 14)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -108,7 +111,7 @@ if (u == true) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) type D = isTrue> ->D : Symbol(D, Decl(unknownType2.ts, 42, 16)) +>D : Symbol(D, Decl(unknownType2.ts, 43, 16)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -119,92 +122,92 @@ if (u == Object) { >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) type E = isTrue> ->E : Symbol(E, Decl(unknownType2.ts, 46, 18)) +>E : Symbol(E, Decl(unknownType2.ts, 47, 18)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } declare const aString: string; ->aString : Symbol(aString, Decl(unknownType2.ts, 50, 13)) +>aString : Symbol(aString, Decl(unknownType2.ts, 51, 13)) declare const aBoolean: boolean; ->aBoolean : Symbol(aBoolean, Decl(unknownType2.ts, 51, 13)) +>aBoolean : Symbol(aBoolean, Decl(unknownType2.ts, 52, 13)) declare const aNumber: number; ->aNumber : Symbol(aNumber, Decl(unknownType2.ts, 52, 13)) +>aNumber : Symbol(aNumber, Decl(unknownType2.ts, 53, 13)) declare const anObject: object; ->anObject : Symbol(anObject, Decl(unknownType2.ts, 53, 13)) +>anObject : Symbol(anObject, Decl(unknownType2.ts, 54, 13)) declare const anObjectLiteral: { x: number }; ->anObjectLiteral : Symbol(anObjectLiteral, Decl(unknownType2.ts, 54, 13)) ->x : Symbol(x, Decl(unknownType2.ts, 54, 32)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(unknownType2.ts, 55, 13)) +>x : Symbol(x, Decl(unknownType2.ts, 55, 32)) declare const aUnion: { x: number } | { y: string }; ->aUnion : Symbol(aUnion, Decl(unknownType2.ts, 55, 13)) ->x : Symbol(x, Decl(unknownType2.ts, 55, 23)) ->y : Symbol(y, Decl(unknownType2.ts, 55, 39)) +>aUnion : Symbol(aUnion, Decl(unknownType2.ts, 56, 13)) +>x : Symbol(x, Decl(unknownType2.ts, 56, 23)) +>y : Symbol(y, Decl(unknownType2.ts, 56, 39)) declare const anIntersection: { x: number } & { y: string }; ->anIntersection : Symbol(anIntersection, Decl(unknownType2.ts, 56, 13)) ->x : Symbol(x, Decl(unknownType2.ts, 56, 31)) ->y : Symbol(y, Decl(unknownType2.ts, 56, 47)) +>anIntersection : Symbol(anIntersection, Decl(unknownType2.ts, 57, 13)) +>x : Symbol(x, Decl(unknownType2.ts, 57, 31)) +>y : Symbol(y, Decl(unknownType2.ts, 57, 47)) declare const aFunction: () => number; ->aFunction : Symbol(aFunction, Decl(unknownType2.ts, 57, 13)) +>aFunction : Symbol(aFunction, Decl(unknownType2.ts, 58, 13)) if (u === aString) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aString : Symbol(aString, Decl(unknownType2.ts, 50, 13)) +>aString : Symbol(aString, Decl(unknownType2.ts, 51, 13)) let uString: string = u; ->uString : Symbol(uString, Decl(unknownType2.ts, 60, 7)) +>uString : Symbol(uString, Decl(unknownType2.ts, 61, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === aBoolean) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aBoolean : Symbol(aBoolean, Decl(unknownType2.ts, 51, 13)) +>aBoolean : Symbol(aBoolean, Decl(unknownType2.ts, 52, 13)) let uString: boolean = u; ->uString : Symbol(uString, Decl(unknownType2.ts, 64, 7)) +>uString : Symbol(uString, Decl(unknownType2.ts, 65, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === aNumber) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aNumber : Symbol(aNumber, Decl(unknownType2.ts, 52, 13)) +>aNumber : Symbol(aNumber, Decl(unknownType2.ts, 53, 13)) let uNumber: number = u; ->uNumber : Symbol(uNumber, Decl(unknownType2.ts, 68, 7)) +>uNumber : Symbol(uNumber, Decl(unknownType2.ts, 69, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === anObject) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->anObject : Symbol(anObject, Decl(unknownType2.ts, 53, 13)) +>anObject : Symbol(anObject, Decl(unknownType2.ts, 54, 13)) let uObject: object = u; ->uObject : Symbol(uObject, Decl(unknownType2.ts, 72, 7)) +>uObject : Symbol(uObject, Decl(unknownType2.ts, 73, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === anObjectLiteral) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->anObjectLiteral : Symbol(anObjectLiteral, Decl(unknownType2.ts, 54, 13)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(unknownType2.ts, 55, 13)) let uObjectLiteral: object = u; ->uObjectLiteral : Symbol(uObjectLiteral, Decl(unknownType2.ts, 76, 7)) +>uObjectLiteral : Symbol(uObjectLiteral, Decl(unknownType2.ts, 77, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } if (u === aUnion) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aUnion : Symbol(aUnion, Decl(unknownType2.ts, 55, 13)) +>aUnion : Symbol(aUnion, Decl(unknownType2.ts, 56, 13)) type unionDoesNotNarrow = isTrue> ->unionDoesNotNarrow : Symbol(unionDoesNotNarrow, Decl(unknownType2.ts, 79, 19)) +>unionDoesNotNarrow : Symbol(unionDoesNotNarrow, Decl(unknownType2.ts, 80, 19)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -212,10 +215,10 @@ if (u === aUnion) { if (u === anIntersection) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->anIntersection : Symbol(anIntersection, Decl(unknownType2.ts, 56, 13)) +>anIntersection : Symbol(anIntersection, Decl(unknownType2.ts, 57, 13)) type intersectionDoesNotNarrow = isTrue> ->intersectionDoesNotNarrow : Symbol(intersectionDoesNotNarrow, Decl(unknownType2.ts, 83, 27)) +>intersectionDoesNotNarrow : Symbol(intersectionDoesNotNarrow, Decl(unknownType2.ts, 84, 27)) >isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) >isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) @@ -223,73 +226,359 @@ if (u === anIntersection) { if (u === aFunction) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->aFunction : Symbol(aFunction, Decl(unknownType2.ts, 57, 13)) +>aFunction : Symbol(aFunction, Decl(unknownType2.ts, 58, 13)) let uFunction: object = u; ->uFunction : Symbol(uFunction, Decl(unknownType2.ts, 88, 7)) +>uFunction : Symbol(uFunction, Decl(unknownType2.ts, 89, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } enum NumberEnum { ->NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 89, 1)) +>NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 90, 1)) A, ->A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 91, 17)) +>A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 92, 17)) B, ->B : Symbol(NumberEnum.B, Decl(unknownType2.ts, 92, 6)) +>B : Symbol(NumberEnum.B, Decl(unknownType2.ts, 93, 6)) C ->C : Symbol(NumberEnum.C, Decl(unknownType2.ts, 93, 6)) +>C : Symbol(NumberEnum.C, Decl(unknownType2.ts, 94, 6)) } enum StringEnum { ->StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 95, 1)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) A = "A", ->A : Symbol(StringEnum.A, Decl(unknownType2.ts, 97, 17)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) B = "B", ->B : Symbol(StringEnum.B, Decl(unknownType2.ts, 98, 12)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) C = "C" ->C : Symbol(StringEnum.C, Decl(unknownType2.ts, 99, 12)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) } if (u === NumberEnum || u === StringEnum) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 89, 1)) +>NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 90, 1)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 95, 1)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) let enumObj: object = u; ->enumObj : Symbol(enumObj, Decl(unknownType2.ts, 104, 7)) +>enumObj : Symbol(enumObj, Decl(unknownType2.ts, 105, 7)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } -if(u === NumberEnum.A) { +if (u === NumberEnum.A) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->NumberEnum.A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 91, 17)) ->NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 89, 1)) ->A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 91, 17)) +>NumberEnum.A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 92, 17)) +>NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 90, 1)) +>A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 92, 17)) let a: NumberEnum.A = u ->a : Symbol(a, Decl(unknownType2.ts, 108, 7)) ->NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 89, 1)) ->A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 91, 17)) +>a : Symbol(a, Decl(unknownType2.ts, 109, 7)) +>NumberEnum : Symbol(NumberEnum, Decl(unknownType2.ts, 90, 1)) +>A : Symbol(NumberEnum.A, Decl(unknownType2.ts, 92, 17)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } -if(u === StringEnum.B) { +if (u === StringEnum.B) { >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) ->StringEnum.B : Symbol(StringEnum.B, Decl(unknownType2.ts, 98, 12)) ->StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 95, 1)) ->B : Symbol(StringEnum.B, Decl(unknownType2.ts, 98, 12)) +>StringEnum.B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) let b: StringEnum.B = u ->b : Symbol(b, Decl(unknownType2.ts, 112, 7)) ->StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 95, 1)) ->B : Symbol(StringEnum.B, Decl(unknownType2.ts, 98, 12)) +>b : Symbol(b, Decl(unknownType2.ts, 113, 7)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) >u : Symbol(u, Decl(unknownType2.ts, 6, 5)) } +function switchTestEnum(x: unknown) { +>switchTestEnum : Symbol(switchTestEnum, Decl(unknownType2.ts, 114, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + case StringEnum.A: +>StringEnum.A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) + + const a: StringEnum.A = x; +>a : Symbol(a, Decl(unknownType2.ts, 119, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + break; + case StringEnum.B: +>StringEnum.B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) + + const b: StringEnum.B = x; +>b : Symbol(b, Decl(unknownType2.ts, 122, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + break; + case StringEnum.C: +>StringEnum.C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) + + const c: StringEnum.C = x; +>c : Symbol(c, Decl(unknownType2.ts, 125, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) + + break; + } + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 127, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 116, 24)) +} + +function switchTestCollectEnum(x: unknown) { +>switchTestCollectEnum : Symbol(switchTestCollectEnum, Decl(unknownType2.ts, 129, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + case StringEnum.A: +>StringEnum.A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) + + const a: StringEnum.A = x; +>a : Symbol(a, Decl(unknownType2.ts, 134, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + case StringEnum.B: +>StringEnum.B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) + + const b: StringEnum.A | StringEnum.B = x; +>b : Symbol(b, Decl(unknownType2.ts, 136, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + case StringEnum.C: +>StringEnum.C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) + + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; +>c : Symbol(c, Decl(unknownType2.ts, 138, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>A : Symbol(StringEnum.A, Decl(unknownType2.ts, 98, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>B : Symbol(StringEnum.B, Decl(unknownType2.ts, 99, 12)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>C : Symbol(StringEnum.C, Decl(unknownType2.ts, 100, 12)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + const all: StringEnum = x; +>all : Symbol(all, Decl(unknownType2.ts, 139, 17)) +>StringEnum : Symbol(StringEnum, Decl(unknownType2.ts, 96, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) + + return; + } + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 141, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 131, 31)) +} + +function switchTestLiterals(x: unknown) { +>switchTestLiterals : Symbol(switchTestLiterals, Decl(unknownType2.ts, 143, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + case 1: + const one: 1 = x; +>one : Symbol(one, Decl(unknownType2.ts, 148, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case 2: + const two: 2 = x; +>two : Symbol(two, Decl(unknownType2.ts, 151, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case 3: + const three: 3 = x; +>three : Symbol(three, Decl(unknownType2.ts, 154, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case true: + const t: true = x; +>t : Symbol(t, Decl(unknownType2.ts, 157, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case false: + const f: false = x; +>f : Symbol(f, Decl(unknownType2.ts, 160, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case "A": + const a: "A" = x; +>a : Symbol(a, Decl(unknownType2.ts, 163, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case undefined: +>undefined : Symbol(undefined) + + const undef: undefined = x; +>undef : Symbol(undef, Decl(unknownType2.ts, 166, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case null: + const llun: null = x; +>llun : Symbol(llun, Decl(unknownType2.ts, 169, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case symb: +>symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) + + const anotherSymbol: typeof symb = x; +>anotherSymbol : Symbol(anotherSymbol, Decl(unknownType2.ts, 172, 17)) +>symb : Symbol(symb, Decl(unknownType2.ts, 8, 13)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + case symbNonUnique: +>symbNonUnique : Symbol(symbNonUnique, Decl(unknownType2.ts, 9, 13)) + + const nonUniqueSymbol: symbol = x; +>nonUniqueSymbol : Symbol(nonUniqueSymbol, Decl(unknownType2.ts, 175, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) + + break; + } + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 177, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 145, 28)) +} + +function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { +>switchTestObjects : Symbol(switchTestObjects, Decl(unknownType2.ts, 179, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) +>y : Symbol(y, Decl(unknownType2.ts, 181, 38)) +>z : Symbol(z, Decl(unknownType2.ts, 181, 53)) +>prop : Symbol(prop, Decl(unknownType2.ts, 181, 58)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) + + case true: + case false: + const bool: boolean = x; +>bool : Symbol(bool, Decl(unknownType2.ts, 185, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) + + break; + case y: +>y : Symbol(y, Decl(unknownType2.ts, 181, 38)) + + const obj1: object = x; +>obj1 : Symbol(obj1, Decl(unknownType2.ts, 188, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) + + break; + case z: +>z : Symbol(z, Decl(unknownType2.ts, 181, 53)) + + const obj2: object = x; +>obj2 : Symbol(obj2, Decl(unknownType2.ts, 191, 17)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) + + break; + } + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 193, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 181, 27)) +} + +function switchResponse(x: unknown): SomeResponse { +>switchResponse : Symbol(switchResponse, Decl(unknownType2.ts, 195, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 197, 24)) +>SomeResponse : Symbol(SomeResponse, Decl(unknownType2.ts, 1, 32)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 197, 24)) + + case 'yes': + case 'no': + case 'idk': + return x; +>x : Symbol(x, Decl(unknownType2.ts, 197, 24)) + + default: + throw new Error('unknown response'); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } + // Arguably this should be never. + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 205, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 197, 24)) +} + +function switchResponseWrong(x: unknown): SomeResponse { +>switchResponseWrong : Symbol(switchResponseWrong, Decl(unknownType2.ts, 208, 1)) +>x : Symbol(x, Decl(unknownType2.ts, 210, 29)) +>SomeResponse : Symbol(SomeResponse, Decl(unknownType2.ts, 1, 32)) + + switch (x) { +>x : Symbol(x, Decl(unknownType2.ts, 210, 29)) + + case 'yes': + case 'no': + case 'maybe': + return x; // error +>x : Symbol(x, Decl(unknownType2.ts, 210, 29)) + + default: + throw new Error('Can you repeat the question?'); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } + // Arguably this should be never. + type End = isTrue> +>End : Symbol(End, Decl(unknownType2.ts, 218, 5)) +>isTrue : Symbol(isTrue, Decl(unknownType2.ts, 0, 53)) +>isUnknown : Symbol(isUnknown, Decl(unknownType2.ts, 0, 0)) +>x : Symbol(x, Decl(unknownType2.ts, 210, 29)) +} + diff --git a/tests/baselines/reference/unknownType2.types b/tests/baselines/reference/unknownType2.types index f90d85525cc..7fc3c3d1038 100644 --- a/tests/baselines/reference/unknownType2.types +++ b/tests/baselines/reference/unknownType2.types @@ -35,6 +35,9 @@ const u: unknown = undefined; declare const symb: unique symbol; >symb : unique symbol +declare const symbNonUnique: symbol; +>symbNonUnique : symbol + if (u === 5) { >u === 5 : boolean >u : unknown @@ -299,7 +302,7 @@ if (u === NumberEnum || u === StringEnum) { >u : object } -if(u === NumberEnum.A) { +if (u === NumberEnum.A) { >u === NumberEnum.A : boolean >u : unknown >NumberEnum.A : NumberEnum.A @@ -312,7 +315,7 @@ if(u === NumberEnum.A) { >u : NumberEnum.A } -if(u === StringEnum.B) { +if (u === StringEnum.B) { >u === StringEnum.B : boolean >u : unknown >StringEnum.B : StringEnum.B @@ -325,3 +328,302 @@ if(u === StringEnum.B) { >u : StringEnum.B } +function switchTestEnum(x: unknown) { +>switchTestEnum : (x: unknown) => void +>x : unknown + + switch (x) { +>x : unknown + + case StringEnum.A: +>StringEnum.A : StringEnum.A +>StringEnum : typeof StringEnum +>A : StringEnum.A + + const a: StringEnum.A = x; +>a : StringEnum.A +>StringEnum : any +>x : StringEnum.A + + break; + case StringEnum.B: +>StringEnum.B : StringEnum.B +>StringEnum : typeof StringEnum +>B : StringEnum.B + + const b: StringEnum.B = x; +>b : StringEnum.B +>StringEnum : any +>x : StringEnum.B + + break; + case StringEnum.C: +>StringEnum.C : StringEnum.C +>StringEnum : typeof StringEnum +>C : StringEnum.C + + const c: StringEnum.C = x; +>c : StringEnum.C +>StringEnum : any +>x : StringEnum.C + + break; + } + type End = isTrue> +>End : true +>x : unknown +} + +function switchTestCollectEnum(x: unknown) { +>switchTestCollectEnum : (x: unknown) => void +>x : unknown + + switch (x) { +>x : unknown + + case StringEnum.A: +>StringEnum.A : StringEnum.A +>StringEnum : typeof StringEnum +>A : StringEnum.A + + const a: StringEnum.A = x; +>a : StringEnum.A +>StringEnum : any +>x : StringEnum.A + + case StringEnum.B: +>StringEnum.B : StringEnum.B +>StringEnum : typeof StringEnum +>B : StringEnum.B + + const b: StringEnum.A | StringEnum.B = x; +>b : StringEnum.A | StringEnum.B +>StringEnum : any +>StringEnum : any +>x : StringEnum.A | StringEnum.B + + case StringEnum.C: +>StringEnum.C : StringEnum.C +>StringEnum : typeof StringEnum +>C : StringEnum.C + + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; +>c : StringEnum +>StringEnum : any +>StringEnum : any +>StringEnum : any +>x : StringEnum + + const all: StringEnum = x; +>all : StringEnum +>x : StringEnum + + return; + } + type End = isTrue> +>End : true +>x : unknown +} + +function switchTestLiterals(x: unknown) { +>switchTestLiterals : (x: unknown) => void +>x : unknown + + switch (x) { +>x : unknown + + case 1: +>1 : 1 + + const one: 1 = x; +>one : 1 +>x : 1 + + break; + case 2: +>2 : 2 + + const two: 2 = x; +>two : 2 +>x : 2 + + break; + case 3: +>3 : 3 + + const three: 3 = x; +>three : 3 +>x : 3 + + break; + case true: +>true : true + + const t: true = x; +>t : true +>true : true +>x : true + + break; + case false: +>false : false + + const f: false = x; +>f : false +>false : false +>x : false + + break; + case "A": +>"A" : "A" + + const a: "A" = x; +>a : "A" +>x : "A" + + break; + case undefined: +>undefined : undefined + + const undef: undefined = x; +>undef : undefined +>x : undefined + + break; + case null: +>null : null + + const llun: null = x; +>llun : null +>null : null +>x : null + + break; + case symb: +>symb : unique symbol + + const anotherSymbol: typeof symb = x; +>anotherSymbol : unique symbol +>symb : unique symbol +>x : unique symbol + + break; + case symbNonUnique: +>symbNonUnique : symbol + + const nonUniqueSymbol: symbol = x; +>nonUniqueSymbol : symbol +>x : symbol + + break; + } + type End = isTrue> +>End : true +>x : unknown +} + +function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { +>switchTestObjects : (x: unknown, y: () => void, z: { prop: number; }) => void +>x : unknown +>y : () => void +>z : { prop: number; } +>prop : number + + switch (x) { +>x : unknown + + case true: +>true : true + + case false: +>false : false + + const bool: boolean = x; +>bool : boolean +>x : boolean + + break; + case y: +>y : () => void + + const obj1: object = x; +>obj1 : object +>x : object + + break; + case z: +>z : { prop: number; } + + const obj2: object = x; +>obj2 : object +>x : object + + break; + } + type End = isTrue> +>End : true +>x : unknown +} + +function switchResponse(x: unknown): SomeResponse { +>switchResponse : (x: unknown) => SomeResponse +>x : unknown + + switch (x) { +>x : unknown + + case 'yes': +>'yes' : "yes" + + case 'no': +>'no' : "no" + + case 'idk': +>'idk' : "idk" + + return x; +>x : SomeResponse + + default: + throw new Error('unknown response'); +>new Error('unknown response') : Error +>Error : ErrorConstructor +>'unknown response' : "unknown response" + } + // Arguably this should be never. + type End = isTrue> +>End : true +>x : unknown +} + +function switchResponseWrong(x: unknown): SomeResponse { +>switchResponseWrong : (x: unknown) => SomeResponse +>x : unknown + + switch (x) { +>x : unknown + + case 'yes': +>'yes' : "yes" + + case 'no': +>'no' : "no" + + case 'maybe': +>'maybe' : "maybe" + + return x; // error +>x : "yes" | "no" | "maybe" + + default: + throw new Error('Can you repeat the question?'); +>new Error('Can you repeat the question?') : Error +>Error : ErrorConstructor +>'Can you repeat the question?' : "Can you repeat the question?" + } + // Arguably this should be never. + type End = isTrue> +>End : true +>x : unknown +} + diff --git a/tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts b/tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts new file mode 100644 index 00000000000..7f8201ade14 --- /dev/null +++ b/tests/cases/compiler/controlFlowFinallyNoCatchAssignments.ts @@ -0,0 +1,15 @@ +// @strict: true +let x: number; +x = Math.random(); +let a: number; +try { + if (x) { + a = 1; + } else { + a = 2; + } +} finally { + console.log(x); +} + +console.log(a); // <- error here \ No newline at end of file diff --git a/tests/cases/compiler/forAwaitForUnion.ts b/tests/cases/compiler/forAwaitForUnion.ts index 65e08ab77a9..f9434e02897 100644 --- a/tests/cases/compiler/forAwaitForUnion.ts +++ b/tests/cases/compiler/forAwaitForUnion.ts @@ -1,6 +1,6 @@ -// @target: esnext +// @target: es2018 // @lib: esnext async function f(source: Iterable | AsyncIterable) { for await (const x of source) { } -} \ No newline at end of file +} diff --git a/tests/cases/compiler/forwardDeclaredCommonTypes01.ts b/tests/cases/compiler/forwardDeclaredCommonTypes01.ts new file mode 100644 index 00000000000..f4eea80ab03 --- /dev/null +++ b/tests/cases/compiler/forwardDeclaredCommonTypes01.ts @@ -0,0 +1,18 @@ +// @lib: es5 +// @target: es5 + +interface Promise {} +interface Symbol {} +interface Map {} +interface WeakMap {} +interface Set {} +interface WeakSet {} + +(function() { + new Promise; + new Symbol; Symbol(); + new Map; + new WeakMap; + new Set; + new WeakSet; +}); diff --git a/tests/cases/compiler/isolatedModulesAmbientConstEnum.ts b/tests/cases/compiler/isolatedModulesAmbientConstEnum.ts index 59fcdcd1fe4..993235c2c0c 100644 --- a/tests/cases/compiler/isolatedModulesAmbientConstEnum.ts +++ b/tests/cases/compiler/isolatedModulesAmbientConstEnum.ts @@ -4,4 +4,4 @@ // @filename: file1.ts declare const enum E { X = 1} -export var y; \ No newline at end of file +export var y = E.X; diff --git a/tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitialization.ts b/tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitialization.ts index 01177200429..fc03101922a 100644 --- a/tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitialization.ts +++ b/tests/cases/conformance/classes/propertyMemberDeclarations/strictPropertyInitialization.ts @@ -99,3 +99,14 @@ class C10 { let y = this.c; } } + +// Property is considered initialized by type any even though value could be undefined + +declare function someValue(): any; + +class C11 { + a: number; + constructor() { + this.a = someValue(); + } +} diff --git a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.classMethods.es2018.ts similarity index 91% rename from tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts rename to tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.classMethods.es2018.ts index fbdcaab4998..6e7dc0622bc 100644 --- a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.classMethods.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.classMethods.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: C1.ts class C1 { diff --git a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2018.ts similarity index 91% rename from tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts rename to tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2018.ts index 2e529c5c92d..ebeee3e4e27 100644 --- a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionDeclarations.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionDeclarations.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: F1.ts async function * f1() { diff --git a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2018.ts similarity index 92% rename from tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts rename to tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2018.ts index 412e3a8a4d6..79bb5a3d255 100644 --- a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.functionExpressions.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.functionExpressions.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: F1.ts const f1 = async function * () { diff --git a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2018.ts similarity index 90% rename from tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts rename to tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2018.ts index ae41cff42b9..d5e1bc7b1f8 100644 --- a/tests/cases/conformance/emitter/esnext/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/asyncGenerators/emitter.asyncGenerators.objectLiteralMethods.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: O1.ts const o1 = { diff --git a/tests/cases/conformance/emitter/esnext/forAwait/emitter.forAwait.esnext.ts b/tests/cases/conformance/emitter/es2018/forAwait/emitter.forAwait.es2018.ts similarity index 92% rename from tests/cases/conformance/emitter/esnext/forAwait/emitter.forAwait.esnext.ts rename to tests/cases/conformance/emitter/es2018/forAwait/emitter.forAwait.es2018.ts index ea1b030599e..02e875fb7e4 100644 --- a/tests/cases/conformance/emitter/esnext/forAwait/emitter.forAwait.esnext.ts +++ b/tests/cases/conformance/emitter/es2018/forAwait/emitter.forAwait.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @filename: file1.ts async function f1() { @@ -39,4 +39,4 @@ async function* f6() { outer: for await (const x of y) { continue outer; } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.classMethods.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.classMethods.es2018.ts similarity index 93% rename from tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.classMethods.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.classMethods.es2018.ts index ffbe79ee292..719d373983b 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.classMethods.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.classMethods.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true // @filename: methodIsOk.ts @@ -146,4 +146,4 @@ class C24 { // @filename: asyncGeneratorPropertyIsError.ts class C25 { async * x = 1; -} \ No newline at end of file +} diff --git a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionDeclarations.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionDeclarations.es2018.ts similarity index 94% rename from tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionDeclarations.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionDeclarations.es2018.ts index fd212595a0c..10cbc2204bb 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionDeclarations.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionDeclarations.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true // @filename: functionDeclarationIsOk.ts @@ -84,4 +84,4 @@ async function * f20() { // @filename: yieldInNestedComputedPropertyIsOk.ts async function * f21() { const x = { [yield]: 1 }; -} \ No newline at end of file +} diff --git a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionExpressions.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionExpressions.es2018.ts similarity index 95% rename from tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionExpressions.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionExpressions.es2018.ts index 1a740a5d5b4..92bbcf50c59 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.functionExpressions.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.functionExpressions.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true // @filename: functionExpressionIsOk.ts diff --git a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.es2018.ts similarity index 93% rename from tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.es2018.ts index 433c24ad2fa..dc9ffb4dddb 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/asyncGenerators/parser.asyncGenerators.objectLiteralMethods.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @skipLibCheck: true // @lib: esnext // @noEmit: true @@ -142,4 +142,4 @@ const o23 = { // @filename: asyncGeneratorPropertyIsError.ts const o24 = { async * x: 1; -}; \ No newline at end of file +}; diff --git a/tests/cases/conformance/parser/ecmascriptnext/forAwait/parser.forAwait.esnext.ts b/tests/cases/conformance/parser/ecmascript2018/forAwait/parser.forAwait.es2018.ts similarity index 93% rename from tests/cases/conformance/parser/ecmascriptnext/forAwait/parser.forAwait.esnext.ts rename to tests/cases/conformance/parser/ecmascript2018/forAwait/parser.forAwait.es2018.ts index 61e9055b874..4619bacfc2a 100644 --- a/tests/cases/conformance/parser/ecmascriptnext/forAwait/parser.forAwait.esnext.ts +++ b/tests/cases/conformance/parser/ecmascript2018/forAwait/parser.forAwait.es2018.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true // @filename: topLevelWithDeclIsError.ts @@ -60,4 +60,4 @@ function* f12() { let x: any, y: any; for await (x of y) { } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts b/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts similarity index 96% rename from tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts rename to tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts index 1d7ebd17807..f31f453ba5f 100644 --- a/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.1.ts +++ b/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true async function * inferReturnType1() { @@ -123,4 +123,4 @@ async function * awaitedType1() { } async function * awaitedType2() { const x = await Promise.resolve(1); -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts b/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts similarity index 96% rename from tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts rename to tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts index 3252189b798..0053f71b986 100644 --- a/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.esnext.2.ts +++ b/tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true async function * inferReturnType1() { @@ -75,4 +75,4 @@ async function * explicitReturnType12(): Iterator { } async function * yieldStar() { yield* {}; -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts similarity index 93% rename from tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts rename to tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts index 8b5157250b8..50173378731 100644 --- a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.1.ts +++ b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true declare const asyncIterable: AsyncIterable; @@ -33,4 +33,4 @@ async function * f2() { } for await (y of iterableOfPromise) { } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts similarity index 90% rename from tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts rename to tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts index b9688862d61..97f4eeb07c6 100644 --- a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.2.ts +++ b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: esnext // @noEmit: true declare const asyncIterable: AsyncIterable; @@ -18,4 +18,4 @@ async function f() { } for (y of asyncIterable) { } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts similarity index 87% rename from tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts rename to tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts index 3f74c17671a..f45adf23a0e 100644 --- a/tests/cases/conformance/types/forAwait/types.forAwait.esnext.3.ts +++ b/tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: es2018 // @lib: es5 // @noEmit: true async function f1() { @@ -14,4 +14,4 @@ async function* f2() { } for await (y of {}) { } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/types/mapped/recursiveMappedTypes.ts b/tests/cases/conformance/types/mapped/recursiveMappedTypes.ts index 188efa2f51a..69a0c1ca597 100644 --- a/tests/cases/conformance/types/mapped/recursiveMappedTypes.ts +++ b/tests/cases/conformance/types/mapped/recursiveMappedTypes.ts @@ -22,3 +22,42 @@ type tup = [number, number, number, number]; function foo(arg: Circular): tup { return arg; } + +// Repro from #29442 + +type DeepMap = { + [K in keyof T]: T[K] extends unknown[] ? DeepMap : R; +}; + +type tpl = [string, [string, [string]]]; +type arr = string[][]; + +type t1 = DeepMap; // [number, [number, [number]]] +type t2 = DeepMap; // number[][] + +// Repro from #29577 + +type Transform = { [K in keyof T]: Transform }; + +interface User { + avatar: string; +} + +interface Guest { + displayName: string; +} + +interface Product { + users: (User | Guest)[]; +} + +declare var product: Transform; +product.users; // (Transform | Transform)[] + +// Repro from #29702 + +type Remap1 = { [P in keyof T]: Remap1; }; +type Remap2 = T extends object ? { [P in keyof T]: Remap2; } : T; + +type a = Remap1; // string[] +type b = Remap2; // string[] diff --git a/tests/cases/conformance/types/unknown/unknownType2.ts b/tests/cases/conformance/types/unknown/unknownType2.ts index f8700958d6b..b3d16654b80 100644 --- a/tests/cases/conformance/types/unknown/unknownType2.ts +++ b/tests/cases/conformance/types/unknown/unknownType2.ts @@ -9,6 +9,7 @@ let validate: (x: unknown) => SomeResponse = x => (x === 'yes' || x === 'no') ? const u: unknown = undefined; declare const symb: unique symbol; +declare const symbNonUnique: symbol; if (u === 5) { const y = u.toString(10); @@ -107,10 +108,117 @@ if (u === NumberEnum || u === StringEnum) { let enumObj: object = u; } -if(u === NumberEnum.A) { +if (u === NumberEnum.A) { let a: NumberEnum.A = u } -if(u === StringEnum.B) { +if (u === StringEnum.B) { let b: StringEnum.B = u } + +function switchTestEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + break; + case StringEnum.B: + const b: StringEnum.B = x; + break; + case StringEnum.C: + const c: StringEnum.C = x; + break; + } + type End = isTrue> +} + +function switchTestCollectEnum(x: unknown) { + switch (x) { + case StringEnum.A: + const a: StringEnum.A = x; + case StringEnum.B: + const b: StringEnum.A | StringEnum.B = x; + case StringEnum.C: + const c: StringEnum.A | StringEnum.B | StringEnum.C = x; + const all: StringEnum = x; + return; + } + type End = isTrue> +} + +function switchTestLiterals(x: unknown) { + switch (x) { + case 1: + const one: 1 = x; + break; + case 2: + const two: 2 = x; + break; + case 3: + const three: 3 = x; + break; + case true: + const t: true = x; + break; + case false: + const f: false = x; + break; + case "A": + const a: "A" = x; + break; + case undefined: + const undef: undefined = x; + break; + case null: + const llun: null = x; + break; + case symb: + const anotherSymbol: typeof symb = x; + break; + case symbNonUnique: + const nonUniqueSymbol: symbol = x; + break; + } + type End = isTrue> +} + +function switchTestObjects(x: unknown, y: () => void, z: { prop: number }) { + switch (x) { + case true: + case false: + const bool: boolean = x; + break; + case y: + const obj1: object = x; + break; + case z: + const obj2: object = x; + break; + } + type End = isTrue> +} + +function switchResponse(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'idk': + return x; + default: + throw new Error('unknown response'); + } + // Arguably this should be never. + type End = isTrue> +} + +function switchResponseWrong(x: unknown): SomeResponse { + switch (x) { + case 'yes': + case 'no': + case 'maybe': + return x; // error + default: + throw new Error('Can you repeat the question?'); + } + // Arguably this should be never. + type End = isTrue> +}